plugins/dali-swig/automatic/cpp/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/public-api/math/matrix.h>
 427 #include <dali/public-api/math/matrix3.h>
 428 #include <dali/public-api/math/viewport.h>
 429 #include <dali/public-api/object/property-key.h>
 430
 431 #include <dali/public-api/adaptor-framework/timer.h>
 432 #include <dali/public-api/adaptor-framework/window.h>
 433 #include <dali/public-api/adaptor-framework/style-change.h>
 434 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 435
 436 #include <dali/devel-api/images/nine-patch-image.h>
 437
 438 #include <dali-toolkit/devel-api/builder/builder.h>
 439 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 440 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 441 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 442 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 443 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 444 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 445 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 446
 447 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 448 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 449
 450 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 451
 452 // add here SWIG version check
 453
 454 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 455 // disable Swig-dependent warnings
 456
 457 // 'identifier1' has C-linkage specified,
 458 // but returns UDT 'identifier2' which is incompatible with C
 459 #pragma warning(disable: 4190)
 460
 461 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 462 #pragma warning(disable: 4800)
 463
 464 // debug info too long etc etc
 465 #pragma warning(disable: 4786)
 466 #endif
 467
 468
 469 #include <stdexcept>
 470
 471
 472 #include <string>
 473
 474
 475 #include <vector>
 476 #include <algorithm>
 477 #include <stdexcept>
 478
 479
 480 #include <map>
 481 #include <algorithm>
 482 #include <stdexcept>
 483
 484
 485 #include <utility>
 486
 487
 488 typedef float floatp;
 489
 490 SWIGINTERN floatp *new_floatp(){
 491   return new float();
 492 }
 493 SWIGINTERN void delete_floatp(floatp *self){
 494   if (self) delete self;
 495 }
 496 SWIGINTERN void floatp_assign(floatp *self,float value){
 497   *self = value;
 498 }
 499 SWIGINTERN float floatp_value(floatp *self){
 500   return *self;
 501 }
 502 SWIGINTERN float *floatp_cast(floatp *self){
 503   return self;
 504 }
 505 SWIGINTERN floatp *floatp_frompointer(float *t){
 506   return (floatp *) t;
 507 }
 508
 509 typedef int intp;
 510
 511 SWIGINTERN intp *new_intp(){
 512   return new int();
 513 }
 514 SWIGINTERN void delete_intp(intp *self){
 515   if (self) delete self;
 516 }
 517 SWIGINTERN void intp_assign(intp *self,int value){
 518   *self = value;
 519 }
 520 SWIGINTERN int intp_value(intp *self){
 521   return *self;
 522 }
 523 SWIGINTERN int *intp_cast(intp *self){
 524   return self;
 525 }
 526 SWIGINTERN intp *intp_frompointer(int *t){
 527   return (intp *) t;
 528 }
 529
 530 typedef double doublep;
 531
 532 SWIGINTERN doublep *new_doublep(){
 533   return new double();
 534 }
 535 SWIGINTERN void delete_doublep(doublep *self){
 536   if (self) delete self;
 537 }
 538 SWIGINTERN void doublep_assign(doublep *self,double value){
 539   *self = value;
 540 }
 541 SWIGINTERN double doublep_value(doublep *self){
 542   return *self;
 543 }
 544 SWIGINTERN double *doublep_cast(doublep *self){
 545   return self;
 546 }
 547 SWIGINTERN doublep *doublep_frompointer(double *t){
 548   return (doublep *) t;
 549 }
 550
 551 typedef unsigned int uintp;
 552
 553 SWIGINTERN uintp *new_uintp(){
 554   return new unsigned int();
 555 }
 556 SWIGINTERN void delete_uintp(uintp *self){
 557   if (self) delete self;
 558 }
 559 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 560   *self = value;
 561 }
 562 SWIGINTERN unsigned int uintp_value(uintp *self){
 563   return *self;
 564 }
 565 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 566   return self;
 567 }
 568 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 569   return (uintp *) t;
 570 }
 571
 572 typedef unsigned short ushortp;
 573
 574 SWIGINTERN ushortp *new_ushortp(){
 575   return new unsigned short();
 576 }
 577 SWIGINTERN void delete_ushortp(ushortp *self){
 578   if (self) delete self;
 579 }
 580 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 581   *self = value;
 582 }
 583 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 584   return *self;
 585 }
 586 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 587   return self;
 588 }
 589 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 590   return (ushortp *) t;
 591 }
 592
 593 unsigned int int_to_uint(int x) {
 594    return (unsigned int) x;
 595 }
 596
 597
 598 using namespace Dali;
 599 using namespace Dali::Toolkit;
 600
 601 SWIGINTERN bool Dali_BaseHandle_IsHandleEmpty(Dali::BaseHandle const *self){
 602      if( *self )
 603      {
 604        return true;
 605      }
 606      else
 607      {
 608        return false;
 609      }
 610     }
 611 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 612         std::vector< Dali::TouchPoint >* pv = 0;
 613         if (capacity >= 0) {
 614           pv = new std::vector< Dali::TouchPoint >();
 615           pv->reserve(capacity);
 616        } else {
 617           throw std::out_of_range("capacity");
 618        }
 619        return pv;
 620       }
 621 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 622         if (index>=0 && index<(int)self->size())
 623           return (*self)[index];
 624         else
 625           throw std::out_of_range("index");
 626       }
 627 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 628         if (index>=0 && index<(int)self->size())
 629           return (*self)[index];
 630         else
 631           throw std::out_of_range("index");
 632       }
 633 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 634         if (index>=0 && index<(int)self->size())
 635           (*self)[index] = val;
 636         else
 637           throw std::out_of_range("index");
 638       }
 639 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 640         self->insert(self->end(), values.begin(), values.end());
 641       }
 642 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 643         if (index < 0)
 644           throw std::out_of_range("index");
 645         if (count < 0)
 646           throw std::out_of_range("count");
 647         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 648           throw std::invalid_argument("invalid range");
 649         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 650       }
 651 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 652         if (index>=0 && index<(int)self->size()+1)
 653           self->insert(self->begin()+index, x);
 654         else
 655           throw std::out_of_range("index");
 656       }
 657 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 658         if (index>=0 && index<(int)self->size()+1)
 659           self->insert(self->begin()+index, values.begin(), values.end());
 660         else
 661           throw std::out_of_range("index");
 662       }
 663 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 664         if (index>=0 && index<(int)self->size())
 665           self->erase(self->begin() + index);
 666         else
 667           throw std::out_of_range("index");
 668       }
 669 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 670         if (index < 0)
 671           throw std::out_of_range("index");
 672         if (count < 0)
 673           throw std::out_of_range("count");
 674         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 675           throw std::invalid_argument("invalid range");
 676         self->erase(self->begin()+index, self->begin()+index+count);
 677       }
 678 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 679         if (count < 0)
 680           throw std::out_of_range("count");
 681         return new std::vector< Dali::TouchPoint >(count, value);
 682       }
 683 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 684         std::reverse(self->begin(), self->end());
 685       }
 686 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 687         if (index < 0)
 688           throw std::out_of_range("index");
 689         if (count < 0)
 690           throw std::out_of_range("count");
 691         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 692           throw std::invalid_argument("invalid range");
 693         std::reverse(self->begin()+index, self->begin()+index+count);
 694       }
 695 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 696         if (index < 0)
 697           throw std::out_of_range("index");
 698         if (index+values.size() > self->size())
 699           throw std::out_of_range("index");
 700         std::copy(values.begin(), values.end(), self->begin()+index);
 701       }
 702 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 703          return self->Empty();
 704       }
 705 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 706         return self->GetConnectionCount();
 707       }
 708 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 709           self->Connect( func );
 710       }
 711 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 712           self->Disconnect( func );
 713       }
 714 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 715           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 716 /*@SWIG@*/ self->Emit( arg );
 717       }
 718 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 719          return self->Empty();
 720       }
 721 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 722         return self->GetConnectionCount();
 723       }
 724 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 725           self->Connect( func );
 726       }
 727 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 728           self->Disconnect( func );
 729       }
 730 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 731           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 732 /*@SWIG@*/ self->Emit( arg );
 733       }
 734 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 735          return self->Empty();
 736       }
 737 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){
 738         return self->GetConnectionCount();
 739       }
 740 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 *)){
 741           self->Connect( func );
 742       }
 743 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 *)){
 744           self->Disconnect( func );
 745       }
 746 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){
 747           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 748 /*@SWIG@*/ self->Emit( arg );
 749       }
 750 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 751          return self->Empty();
 752       }
 753 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 754         return self->GetConnectionCount();
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 757           self->Connect( func );
 758       }
 759 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 760           self->Disconnect( func );
 761       }
 762 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 763           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 764 /*@SWIG@*/ self->Emit( arg );
 765       }
 766 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 767          return self->Empty();
 768       }
 769 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 770         return self->GetConnectionCount();
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 773           self->Connect( func );
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 776           self->Disconnect( func );
 777       }
 778 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 779           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 780 /*@SWIG@*/ self->Emit( arg );
 781       }
 782 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){
 783          return self->Empty();
 784       }
 785 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){
 786         return self->GetConnectionCount();
 787       }
 788 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 &)){
 789         self->Connect( func );
 790       }
 791 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 &)){
 792         self->Disconnect( func );
 793       }
 794 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){
 795         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 796 /*@SWIG@*/ self->Emit( arg1, arg2 );
 797       }
 798 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){
 799          return self->Empty();
 800       }
 801 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){
 802         return self->GetConnectionCount();
 803       }
 804 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 &)){
 805         self->Connect( func );
 806       }
 807 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 &)){
 808         self->Disconnect( func );
 809       }
 810 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){
 811         return self->Emit( arg1, arg2 );
 812       }
 813 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){
 814          return self->Empty();
 815       }
 816 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){
 817         return self->GetConnectionCount();
 818       }
 819 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 &)){
 820         self->Connect( func );
 821       }
 822 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 &)){
 823         self->Disconnect( func );
 824       }
 825 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){
 826         return self->Emit( arg1, arg2 );
 827       }
 828 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){
 829          return self->Empty();
 830       }
 831 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){
 832         return self->GetConnectionCount();
 833       }
 834 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 &)){
 835         self->Connect( func );
 836       }
 837 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 &)){
 838         self->Disconnect( func );
 839       }
 840 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){
 841         return self->Emit( arg1, arg2 );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 844          return self->Empty();
 845       }
 846 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 847         return self->GetConnectionCount();
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 850           self->Connect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 853           self->Disconnect( func );
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 856           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 857 /*@SWIG@*/ self->Emit( arg );
 858       }
 859 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 860          return self->Empty();
 861       }
 862 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){
 863         return self->GetConnectionCount();
 864       }
 865 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 &)){
 866           self->Connect( func );
 867       }
 868 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 &)){
 869           self->Disconnect( func );
 870       }
 871 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){
 872           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 873 /*@SWIG@*/ self->Emit( arg );
 874       }
 875 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 876          return self->Empty();
 877       }
 878 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){
 879         return self->GetConnectionCount();
 880       }
 881 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 &)){
 882           self->Connect( func );
 883       }
 884 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 &)){
 885           self->Disconnect( func );
 886       }
 887 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){
 888           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 889 /*@SWIG@*/ self->Emit( arg );
 890       }
 891 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 892          return self->Empty();
 893       }
 894 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){
 895         return self->GetConnectionCount();
 896       }
 897 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 &)){
 898           self->Connect( func );
 899       }
 900 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 &)){
 901           self->Disconnect( func );
 902       }
 903 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){
 904           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 905 /*@SWIG@*/ self->Emit( arg );
 906       }
 907 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){
 908          return self->Empty();
 909       }
 910 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){
 911         return self->GetConnectionCount();
 912       }
 913 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 &)){
 914         self->Connect( func );
 915       }
 916 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 &)){
 917         self->Disconnect( func );
 918       }
 919 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){
 920         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 921 /*@SWIG@*/ self->Emit( arg1, arg2 );
 922       }
 923 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){
 924          return self->Empty();
 925       }
 926 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){
 927         return self->GetConnectionCount();
 928       }
 929 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 &)){
 930         self->Connect( func );
 931       }
 932 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 &)){
 933         self->Disconnect( func );
 934       }
 935 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){
 936         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 937 /*@SWIG@*/ self->Emit( arg1, arg2 );
 938       }
 939 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){
 940          return self->Empty();
 941       }
 942 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){
 943         return self->GetConnectionCount();
 944       }
 945 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 &)){
 946         self->Connect( func );
 947       }
 948 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 &)){
 949         self->Disconnect( func );
 950       }
 951 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){
 952         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 953 /*@SWIG@*/ self->Emit( arg1, arg2 );
 954       }
 955 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 956          return self->Empty();
 957       }
 958 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
 959         return self->GetConnectionCount();
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 962           self->Connect( func );
 963       }
 964 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 965           self->Disconnect( func );
 966       }
 967 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
 968           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 969 /*@SWIG@*/ self->Emit( arg );
 970       }
 971 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
 972          return self->Empty();
 973       }
 974 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
 975         return self->GetConnectionCount();
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
 978           self->Connect( func );
 979       }
 980 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
 981           self->Disconnect( func );
 982       }
 983 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
 984           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 985 /*@SWIG@*/ self->Emit( arg );
 986       }
 987
 988   // keep argcs and argv so they're always available to DALi
 989   int argC = 1;
 990   char **argV = NULL;
 991
 992 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
 993          return self->Empty();
 994       }
 995 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
 996         return self->GetConnectionCount();
 997       }
 998 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
 999           self->Connect( func );
1000       }
1001 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1002           self->Disconnect( func );
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1005           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1006 /*@SWIG@*/ self->Emit( arg );
1007       }
1008 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1009          return self->Empty();
1010       }
1011 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){
1012         return self->GetConnectionCount();
1013       }
1014 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 *)){
1015         self->Connect( func );
1016       }
1017 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 *)){
1018         self->Disconnect( func );
1019       }
1020 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){
1021         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1022 /*@SWIG@*/ self->Emit( arg1, arg2 );
1023       }
1024 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1025         std::vector< unsigned int >* pv = 0;
1026         if (capacity >= 0) {
1027           pv = new std::vector< unsigned int >();
1028           pv->reserve(capacity);
1029        } else {
1030           throw std::out_of_range("capacity");
1031        }
1032        return pv;
1033       }
1034 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1035         if (index>=0 && index<(int)self->size())
1036           return (*self)[index];
1037         else
1038           throw std::out_of_range("index");
1039       }
1040 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1041         if (index>=0 && index<(int)self->size())
1042           return (*self)[index];
1043         else
1044           throw std::out_of_range("index");
1045       }
1046 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1047         if (index>=0 && index<(int)self->size())
1048           (*self)[index] = val;
1049         else
1050           throw std::out_of_range("index");
1051       }
1052 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1053         self->insert(self->end(), values.begin(), values.end());
1054       }
1055 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1056         if (index < 0)
1057           throw std::out_of_range("index");
1058         if (count < 0)
1059           throw std::out_of_range("count");
1060         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1061           throw std::invalid_argument("invalid range");
1062         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1063       }
1064 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1065         if (index>=0 && index<(int)self->size()+1)
1066           self->insert(self->begin()+index, x);
1067         else
1068           throw std::out_of_range("index");
1069       }
1070 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1071         if (index>=0 && index<(int)self->size()+1)
1072           self->insert(self->begin()+index, values.begin(), values.end());
1073         else
1074           throw std::out_of_range("index");
1075       }
1076 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1077         if (index>=0 && index<(int)self->size())
1078           self->erase(self->begin() + index);
1079         else
1080           throw std::out_of_range("index");
1081       }
1082 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1083         if (index < 0)
1084           throw std::out_of_range("index");
1085         if (count < 0)
1086           throw std::out_of_range("count");
1087         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1088           throw std::invalid_argument("invalid range");
1089         self->erase(self->begin()+index, self->begin()+index+count);
1090       }
1091 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1092         if (count < 0)
1093           throw std::out_of_range("count");
1094         return new std::vector< unsigned int >(count, value);
1095       }
1096 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1097         std::reverse(self->begin(), self->end());
1098       }
1099 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1100         if (index < 0)
1101           throw std::out_of_range("index");
1102         if (count < 0)
1103           throw std::out_of_range("count");
1104         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1105           throw std::invalid_argument("invalid range");
1106         std::reverse(self->begin()+index, self->begin()+index+count);
1107       }
1108 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1109         if (index < 0)
1110           throw std::out_of_range("index");
1111         if (index+values.size() > self->size())
1112           throw std::out_of_range("index");
1113         std::copy(values.begin(), values.end(), self->begin()+index);
1114       }
1115 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1116         return std::find(self->begin(), self->end(), value) != self->end();
1117       }
1118 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1119         int index = -1;
1120         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1121         if (it != self->end())
1122           index = (int)(it - self->begin());
1123         return index;
1124       }
1125 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1126         int index = -1;
1127         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1128         if (rit != self->rend())
1129           index = (int)(self->rend() - 1 - rit);
1130         return index;
1131       }
1132 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1133         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1134         if (it != self->end()) {
1135           self->erase(it);
1136           return true;
1137         }
1138         return false;
1139       }
1140 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){
1141         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1142         if (capacity >= 0) {
1143           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1144           pv->reserve(capacity);
1145        } else {
1146           throw std::out_of_range("capacity");
1147        }
1148        return pv;
1149       }
1150 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){
1151         if (index>=0 && index<(int)self->size())
1152           return (*self)[index];
1153         else
1154           throw std::out_of_range("index");
1155       }
1156 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){
1157         if (index>=0 && index<(int)self->size())
1158           return (*self)[index];
1159         else
1160           throw std::out_of_range("index");
1161       }
1162 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){
1163         if (index>=0 && index<(int)self->size())
1164           (*self)[index] = val;
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 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){
1169         self->insert(self->end(), values.begin(), values.end());
1170       }
1171 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){
1172         if (index < 0)
1173           throw std::out_of_range("index");
1174         if (count < 0)
1175           throw std::out_of_range("count");
1176         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1177           throw std::invalid_argument("invalid range");
1178         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1179       }
1180 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){
1181         if (index>=0 && index<(int)self->size()+1)
1182           self->insert(self->begin()+index, x);
1183         else
1184           throw std::out_of_range("index");
1185       }
1186 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){
1187         if (index>=0 && index<(int)self->size()+1)
1188           self->insert(self->begin()+index, values.begin(), values.end());
1189         else
1190           throw std::out_of_range("index");
1191       }
1192 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){
1193         if (index>=0 && index<(int)self->size())
1194           self->erase(self->begin() + index);
1195         else
1196           throw std::out_of_range("index");
1197       }
1198 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){
1199         if (index < 0)
1200           throw std::out_of_range("index");
1201         if (count < 0)
1202           throw std::out_of_range("count");
1203         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1204           throw std::invalid_argument("invalid range");
1205         self->erase(self->begin()+index, self->begin()+index+count);
1206       }
1207 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){
1208         if (count < 0)
1209           throw std::out_of_range("count");
1210         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1211       }
1212 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){
1213         std::reverse(self->begin(), self->end());
1214       }
1215 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){
1216         if (index < 0)
1217           throw std::out_of_range("index");
1218         if (count < 0)
1219           throw std::out_of_range("count");
1220         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1221           throw std::invalid_argument("invalid range");
1222         std::reverse(self->begin()+index, self->begin()+index+count);
1223       }
1224 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){
1225         if (index < 0)
1226           throw std::out_of_range("index");
1227         if (index+values.size() > self->size())
1228           throw std::out_of_range("index");
1229         std::copy(values.begin(), values.end(), self->begin()+index);
1230       }
1231 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1232         std::vector< Dali::Actor >* pv = 0;
1233         if (capacity >= 0) {
1234           pv = new std::vector< Dali::Actor >();
1235           pv->reserve(capacity);
1236        } else {
1237           throw std::out_of_range("capacity");
1238        }
1239        return pv;
1240       }
1241 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1242         if (index>=0 && index<(int)self->size())
1243           return (*self)[index];
1244         else
1245           throw std::out_of_range("index");
1246       }
1247 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1248         if (index>=0 && index<(int)self->size())
1249           return (*self)[index];
1250         else
1251           throw std::out_of_range("index");
1252       }
1253 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1254         if (index>=0 && index<(int)self->size())
1255           (*self)[index] = val;
1256         else
1257           throw std::out_of_range("index");
1258       }
1259 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1260         self->insert(self->end(), values.begin(), values.end());
1261       }
1262 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1263         if (index < 0)
1264           throw std::out_of_range("index");
1265         if (count < 0)
1266           throw std::out_of_range("count");
1267         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1268           throw std::invalid_argument("invalid range");
1269         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1270       }
1271 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1272         if (index>=0 && index<(int)self->size()+1)
1273           self->insert(self->begin()+index, x);
1274         else
1275           throw std::out_of_range("index");
1276       }
1277 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1278         if (index>=0 && index<(int)self->size()+1)
1279           self->insert(self->begin()+index, values.begin(), values.end());
1280         else
1281           throw std::out_of_range("index");
1282       }
1283 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1284         if (index>=0 && index<(int)self->size())
1285           self->erase(self->begin() + index);
1286         else
1287           throw std::out_of_range("index");
1288       }
1289 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1290         if (index < 0)
1291           throw std::out_of_range("index");
1292         if (count < 0)
1293           throw std::out_of_range("count");
1294         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1295           throw std::invalid_argument("invalid range");
1296         self->erase(self->begin()+index, self->begin()+index+count);
1297       }
1298 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1299         if (count < 0)
1300           throw std::out_of_range("count");
1301         return new std::vector< Dali::Actor >(count, value);
1302       }
1303 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1304         std::reverse(self->begin(), self->end());
1305       }
1306 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1307         if (index < 0)
1308           throw std::out_of_range("index");
1309         if (count < 0)
1310           throw std::out_of_range("count");
1311         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1312           throw std::invalid_argument("invalid range");
1313         std::reverse(self->begin()+index, self->begin()+index+count);
1314       }
1315 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1316         if (index < 0)
1317           throw std::out_of_range("index");
1318         if (index+values.size() > self->size())
1319           throw std::out_of_range("index");
1320         std::copy(values.begin(), values.end(), self->begin()+index);
1321       }
1322 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1323          return self->Empty();
1324       }
1325 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1326         return self->GetConnectionCount();
1327       }
1328 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 &)){
1329           self->Connect( func );
1330       }
1331 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 &)){
1332           self->Disconnect( func );
1333       }
1334 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){
1335           return self->Emit( arg );
1336       }
1337 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){
1338          return self->Empty();
1339       }
1340 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){
1341         return self->GetConnectionCount();
1342       }
1343 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 &)){
1344         self->Connect( func );
1345       }
1346 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 &)){
1347         self->Disconnect( func );
1348       }
1349 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){
1350         return self->Emit( arg1, arg2 );
1351       }
1352 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){
1353          return self->Empty();
1354       }
1355 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){
1356         return self->GetConnectionCount();
1357       }
1358 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)){
1359         self->Connect( func );
1360       }
1361 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)){
1362         self->Disconnect( func );
1363       }
1364 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){
1365         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1366 /*@SWIG@*/ self->Emit( arg1, arg2 );
1367       }
1368 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1369          return self->Empty();
1370       }
1371 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){
1372         return self->GetConnectionCount();
1373       }
1374 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)){
1375         self->Connect( func );
1376       }
1377 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)){
1378         self->Disconnect( func );
1379       }
1380 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){
1381         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1382 /*@SWIG@*/ self->Emit( arg1, arg2 );
1383       }
1384 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1385          return self->Empty();
1386       }
1387 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1388         return self->GetConnectionCount();
1389       }
1390 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)){
1391         self->Connect( func );
1392       }
1393 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)){
1394         self->Disconnect( func );
1395       }
1396 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){
1397         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1398 /*@SWIG@*/ self->Emit( arg1, arg2 );
1399       }
1400 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){
1401          return self->Empty();
1402       }
1403 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){
1404         return self->GetConnectionCount();
1405       }
1406 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)){
1407         self->Connect( func );
1408       }
1409 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)){
1410         self->Disconnect( func );
1411       }
1412 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){
1413         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1414 /*@SWIG@*/ self->Emit( arg1, arg2 );
1415       }
1416 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1417          return self->Empty();
1418       }
1419 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1420         return self->GetConnectionCount();
1421       }
1422 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)){
1423           self->Connect( func );
1424       }
1425 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)){
1426           self->Disconnect( func );
1427       }
1428 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1429           return self->Emit( arg );
1430       }
1431 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1432          return self->Empty();
1433       }
1434 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1435         return self->GetConnectionCount();
1436       }
1437 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)){
1438           self->Connect( func );
1439       }
1440 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)){
1441           self->Disconnect( func );
1442       }
1443 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1444           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1445 /*@SWIG@*/ self->Emit( arg );
1446       }
1447 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){
1448          return self->Empty();
1449       }
1450 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){
1451         return self->GetConnectionCount();
1452       }
1453 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)){
1454           return self->Connect( func );
1455       }
1456 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)){
1457           self->Disconnect( func );
1458       }
1459 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){
1460           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1461 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1462       }
1463 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1464          return self->Empty();
1465       }
1466 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1467         return self->GetConnectionCount();
1468       }
1469 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)){
1470           self->Connect( func );
1471       }
1472 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)){
1473           self->Disconnect( func );
1474       }
1475 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1476           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1477 /*@SWIG@*/ self->Emit( arg );
1478       }
1479 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){
1480          return self->Empty();
1481       }
1482 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){
1483         return self->GetConnectionCount();
1484       }
1485 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 &)){
1486           self->Connect( func );
1487       }
1488 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 &)){
1489           self->Disconnect( func );
1490       }
1491 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){
1492           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1493 /*@SWIG@*/ self->Emit( arg );
1494       }
1495 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1496          return self->Empty();
1497       }
1498 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){
1499         return self->GetConnectionCount();
1500       }
1501 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 &)){
1502           self->Connect( func );
1503       }
1504 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 &)){
1505           self->Disconnect( func );
1506       }
1507 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){
1508           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1509 /*@SWIG@*/ self->Emit( arg );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1512          return self->Empty();
1513       }
1514 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1515         return self->GetConnectionCount();
1516       }
1517 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)){
1518           self->Connect( func );
1519       }
1520 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)){
1521           self->Disconnect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1524           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1525 /*@SWIG@*/ self->Emit( arg );
1526       }
1527 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1528          return self->Empty();
1529       }
1530 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1531         return self->GetConnectionCount();
1532       }
1533 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)){
1534           self->Connect( func );
1535       }
1536 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)){
1537           self->Disconnect( func );
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1540           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1541 /*@SWIG@*/ self->Emit( arg );
1542       }
1543 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){
1544          return self->Empty();
1545       }
1546 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){
1547         return self->GetConnectionCount();
1548       }
1549 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 &)){
1550         self->Connect( func );
1551       }
1552 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 &)){
1553         self->Disconnect( func );
1554       }
1555 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){
1556         return self->Emit( arg1, arg2 );
1557       }
1558 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1559          return self->Empty();
1560       }
1561 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1562         return self->GetConnectionCount();
1563       }
1564 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)){
1565           self->Connect( func );
1566       }
1567 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)){
1568           self->Disconnect( func );
1569       }
1570 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1571           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1572 /*@SWIG@*/ self->Emit( arg );
1573       }
1574 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1575          return self->Empty();
1576       }
1577 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1578         return self->GetConnectionCount();
1579       }
1580 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 &)){
1581           self->Connect( func );
1582       }
1583 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 &)){
1584           self->Disconnect( func );
1585       }
1586 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){
1587           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1588 /*@SWIG@*/ self->Emit( arg );
1589       }
1590 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1591          return self->Empty();
1592       }
1593 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){
1594         return self->GetConnectionCount();
1595       }
1596 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)){
1597         self->Connect( func );
1598       }
1599 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)){
1600         self->Disconnect( func );
1601       }
1602 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){
1603         return self->Emit( arg1, arg2 );
1604       }
1605 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1606          return self->Empty();
1607       }
1608 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){
1609         return self->GetConnectionCount();
1610       }
1611 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)){
1612         self->Connect( func );
1613       }
1614 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)){
1615         self->Disconnect( func );
1616       }
1617 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){
1618         return self->Emit( arg1, arg2 );
1619       }
1620
1621
1622 /* ---------------------------------------------------
1623  * C++ director class methods
1624  * --------------------------------------------------- */
1625
1626 #include "dali_wrap.h"
1627
1628
1629 #ifdef __cplusplus
1630 extern "C" {
1631 #endif
1632
1633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
1634   void * jresult ;
1635   floatp *result = 0 ;
1636
1637   {
1638     try {
1639       result = (floatp *)new_floatp();
1640     } catch (std::out_of_range& e) {
1641       {
1642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1643       };
1644     } catch (std::exception& e) {
1645       {
1646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1647       };
1648     } catch (...) {
1649       {
1650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1651       };
1652     }
1653   }
1654   jresult = (void *)result;
1655   return jresult;
1656 }
1657
1658
1659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
1660   floatp *arg1 = (floatp *) 0 ;
1661
1662   arg1 = (floatp *)jarg1;
1663   {
1664     try {
1665       delete_floatp(arg1);
1666     } catch (std::out_of_range& e) {
1667       {
1668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1669       };
1670     } catch (std::exception& e) {
1671       {
1672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1673       };
1674     } catch (...) {
1675       {
1676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1677       };
1678     }
1679   }
1680 }
1681
1682
1683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
1684   floatp *arg1 = (floatp *) 0 ;
1685   float arg2 ;
1686
1687   arg1 = (floatp *)jarg1;
1688   arg2 = (float)jarg2;
1689   {
1690     try {
1691       floatp_assign(arg1,arg2);
1692     } catch (std::out_of_range& e) {
1693       {
1694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1695       };
1696     } catch (std::exception& e) {
1697       {
1698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1699       };
1700     } catch (...) {
1701       {
1702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1703       };
1704     }
1705   }
1706 }
1707
1708
1709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
1710   float jresult ;
1711   floatp *arg1 = (floatp *) 0 ;
1712   float result;
1713
1714   arg1 = (floatp *)jarg1;
1715   {
1716     try {
1717       result = (float)floatp_value(arg1);
1718     } catch (std::out_of_range& e) {
1719       {
1720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1721       };
1722     } catch (std::exception& e) {
1723       {
1724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1725       };
1726     } catch (...) {
1727       {
1728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1729       };
1730     }
1731   }
1732   jresult = result;
1733   return jresult;
1734 }
1735
1736
1737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
1738   void * jresult ;
1739   floatp *arg1 = (floatp *) 0 ;
1740   float *result = 0 ;
1741
1742   arg1 = (floatp *)jarg1;
1743   {
1744     try {
1745       result = (float *)floatp_cast(arg1);
1746     } catch (std::out_of_range& e) {
1747       {
1748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1749       };
1750     } catch (std::exception& e) {
1751       {
1752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1753       };
1754     } catch (...) {
1755       {
1756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1757       };
1758     }
1759   }
1760   jresult = (void *)result;
1761   return jresult;
1762 }
1763
1764
1765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
1766   void * jresult ;
1767   float *arg1 = (float *) 0 ;
1768   floatp *result = 0 ;
1769
1770   arg1 = (float *)jarg1;
1771   {
1772     try {
1773       result = (floatp *)floatp_frompointer(arg1);
1774     } catch (std::out_of_range& e) {
1775       {
1776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1777       };
1778     } catch (std::exception& e) {
1779       {
1780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1781       };
1782     } catch (...) {
1783       {
1784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1785       };
1786     }
1787   }
1788   jresult = (void *)result;
1789   return jresult;
1790 }
1791
1792
1793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
1794   void * jresult ;
1795   intp *result = 0 ;
1796
1797   {
1798     try {
1799       result = (intp *)new_intp();
1800     } catch (std::out_of_range& e) {
1801       {
1802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1803       };
1804     } catch (std::exception& e) {
1805       {
1806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1807       };
1808     } catch (...) {
1809       {
1810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1811       };
1812     }
1813   }
1814   jresult = (void *)result;
1815   return jresult;
1816 }
1817
1818
1819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
1820   intp *arg1 = (intp *) 0 ;
1821
1822   arg1 = (intp *)jarg1;
1823   {
1824     try {
1825       delete_intp(arg1);
1826     } catch (std::out_of_range& e) {
1827       {
1828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1829       };
1830     } catch (std::exception& e) {
1831       {
1832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1833       };
1834     } catch (...) {
1835       {
1836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1837       };
1838     }
1839   }
1840 }
1841
1842
1843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
1844   intp *arg1 = (intp *) 0 ;
1845   int arg2 ;
1846
1847   arg1 = (intp *)jarg1;
1848   arg2 = (int)jarg2;
1849   {
1850     try {
1851       intp_assign(arg1,arg2);
1852     } catch (std::out_of_range& e) {
1853       {
1854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1855       };
1856     } catch (std::exception& e) {
1857       {
1858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1859       };
1860     } catch (...) {
1861       {
1862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1863       };
1864     }
1865   }
1866 }
1867
1868
1869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
1870   int jresult ;
1871   intp *arg1 = (intp *) 0 ;
1872   int result;
1873
1874   arg1 = (intp *)jarg1;
1875   {
1876     try {
1877       result = (int)intp_value(arg1);
1878     } catch (std::out_of_range& e) {
1879       {
1880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1881       };
1882     } catch (std::exception& e) {
1883       {
1884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1885       };
1886     } catch (...) {
1887       {
1888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1889       };
1890     }
1891   }
1892   jresult = result;
1893   return jresult;
1894 }
1895
1896
1897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
1898   void * jresult ;
1899   intp *arg1 = (intp *) 0 ;
1900   int *result = 0 ;
1901
1902   arg1 = (intp *)jarg1;
1903   {
1904     try {
1905       result = (int *)intp_cast(arg1);
1906     } catch (std::out_of_range& e) {
1907       {
1908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1909       };
1910     } catch (std::exception& e) {
1911       {
1912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1913       };
1914     } catch (...) {
1915       {
1916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1917       };
1918     }
1919   }
1920   jresult = (void *)result;
1921   return jresult;
1922 }
1923
1924
1925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
1926   void * jresult ;
1927   int *arg1 = (int *) 0 ;
1928   intp *result = 0 ;
1929
1930   arg1 = (int *)jarg1;
1931   {
1932     try {
1933       result = (intp *)intp_frompointer(arg1);
1934     } catch (std::out_of_range& e) {
1935       {
1936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1937       };
1938     } catch (std::exception& e) {
1939       {
1940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1941       };
1942     } catch (...) {
1943       {
1944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1945       };
1946     }
1947   }
1948   jresult = (void *)result;
1949   return jresult;
1950 }
1951
1952
1953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
1954   void * jresult ;
1955   doublep *result = 0 ;
1956
1957   {
1958     try {
1959       result = (doublep *)new_doublep();
1960     } catch (std::out_of_range& e) {
1961       {
1962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1963       };
1964     } catch (std::exception& e) {
1965       {
1966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1967       };
1968     } catch (...) {
1969       {
1970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1971       };
1972     }
1973   }
1974   jresult = (void *)result;
1975   return jresult;
1976 }
1977
1978
1979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
1980   doublep *arg1 = (doublep *) 0 ;
1981
1982   arg1 = (doublep *)jarg1;
1983   {
1984     try {
1985       delete_doublep(arg1);
1986     } catch (std::out_of_range& e) {
1987       {
1988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1989       };
1990     } catch (std::exception& e) {
1991       {
1992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1993       };
1994     } catch (...) {
1995       {
1996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1997       };
1998     }
1999   }
2000 }
2001
2002
2003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2004   doublep *arg1 = (doublep *) 0 ;
2005   double arg2 ;
2006
2007   arg1 = (doublep *)jarg1;
2008   arg2 = (double)jarg2;
2009   {
2010     try {
2011       doublep_assign(arg1,arg2);
2012     } catch (std::out_of_range& e) {
2013       {
2014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2015       };
2016     } catch (std::exception& e) {
2017       {
2018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2019       };
2020     } catch (...) {
2021       {
2022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2023       };
2024     }
2025   }
2026 }
2027
2028
2029 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2030   double jresult ;
2031   doublep *arg1 = (doublep *) 0 ;
2032   double result;
2033
2034   arg1 = (doublep *)jarg1;
2035   {
2036     try {
2037       result = (double)doublep_value(arg1);
2038     } catch (std::out_of_range& e) {
2039       {
2040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2041       };
2042     } catch (std::exception& e) {
2043       {
2044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2045       };
2046     } catch (...) {
2047       {
2048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2049       };
2050     }
2051   }
2052   jresult = result;
2053   return jresult;
2054 }
2055
2056
2057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2058   void * jresult ;
2059   doublep *arg1 = (doublep *) 0 ;
2060   double *result = 0 ;
2061
2062   arg1 = (doublep *)jarg1;
2063   {
2064     try {
2065       result = (double *)doublep_cast(arg1);
2066     } catch (std::out_of_range& e) {
2067       {
2068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2069       };
2070     } catch (std::exception& e) {
2071       {
2072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2073       };
2074     } catch (...) {
2075       {
2076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2077       };
2078     }
2079   }
2080   jresult = (void *)result;
2081   return jresult;
2082 }
2083
2084
2085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2086   void * jresult ;
2087   double *arg1 = (double *) 0 ;
2088   doublep *result = 0 ;
2089
2090   arg1 = (double *)jarg1;
2091   {
2092     try {
2093       result = (doublep *)doublep_frompointer(arg1);
2094     } catch (std::out_of_range& e) {
2095       {
2096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2097       };
2098     } catch (std::exception& e) {
2099       {
2100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2101       };
2102     } catch (...) {
2103       {
2104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2105       };
2106     }
2107   }
2108   jresult = (void *)result;
2109   return jresult;
2110 }
2111
2112
2113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2114   void * jresult ;
2115   uintp *result = 0 ;
2116
2117   {
2118     try {
2119       result = (uintp *)new_uintp();
2120     } catch (std::out_of_range& e) {
2121       {
2122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2123       };
2124     } catch (std::exception& e) {
2125       {
2126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2127       };
2128     } catch (...) {
2129       {
2130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2131       };
2132     }
2133   }
2134   jresult = (void *)result;
2135   return jresult;
2136 }
2137
2138
2139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2140   uintp *arg1 = (uintp *) 0 ;
2141
2142   arg1 = (uintp *)jarg1;
2143   {
2144     try {
2145       delete_uintp(arg1);
2146     } catch (std::out_of_range& e) {
2147       {
2148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2149       };
2150     } catch (std::exception& e) {
2151       {
2152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2153       };
2154     } catch (...) {
2155       {
2156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2157       };
2158     }
2159   }
2160 }
2161
2162
2163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2164   uintp *arg1 = (uintp *) 0 ;
2165   unsigned int arg2 ;
2166
2167   arg1 = (uintp *)jarg1;
2168   arg2 = (unsigned int)jarg2;
2169   {
2170     try {
2171       uintp_assign(arg1,arg2);
2172     } catch (std::out_of_range& e) {
2173       {
2174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2175       };
2176     } catch (std::exception& e) {
2177       {
2178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2179       };
2180     } catch (...) {
2181       {
2182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2183       };
2184     }
2185   }
2186 }
2187
2188
2189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2190   unsigned int jresult ;
2191   uintp *arg1 = (uintp *) 0 ;
2192   unsigned int result;
2193
2194   arg1 = (uintp *)jarg1;
2195   {
2196     try {
2197       result = (unsigned int)uintp_value(arg1);
2198     } catch (std::out_of_range& e) {
2199       {
2200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2201       };
2202     } catch (std::exception& e) {
2203       {
2204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2205       };
2206     } catch (...) {
2207       {
2208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2209       };
2210     }
2211   }
2212   jresult = result;
2213   return jresult;
2214 }
2215
2216
2217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2218   void * jresult ;
2219   uintp *arg1 = (uintp *) 0 ;
2220   unsigned int *result = 0 ;
2221
2222   arg1 = (uintp *)jarg1;
2223   {
2224     try {
2225       result = (unsigned int *)uintp_cast(arg1);
2226     } catch (std::out_of_range& e) {
2227       {
2228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2229       };
2230     } catch (std::exception& e) {
2231       {
2232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2233       };
2234     } catch (...) {
2235       {
2236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2237       };
2238     }
2239   }
2240   jresult = (void *)result;
2241   return jresult;
2242 }
2243
2244
2245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2246   void * jresult ;
2247   unsigned int *arg1 = (unsigned int *) 0 ;
2248   uintp *result = 0 ;
2249
2250   arg1 = (unsigned int *)jarg1;
2251   {
2252     try {
2253       result = (uintp *)uintp_frompointer(arg1);
2254     } catch (std::out_of_range& e) {
2255       {
2256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2257       };
2258     } catch (std::exception& e) {
2259       {
2260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2261       };
2262     } catch (...) {
2263       {
2264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2265       };
2266     }
2267   }
2268   jresult = (void *)result;
2269   return jresult;
2270 }
2271
2272
2273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2274   void * jresult ;
2275   ushortp *result = 0 ;
2276
2277   {
2278     try {
2279       result = (ushortp *)new_ushortp();
2280     } catch (std::out_of_range& e) {
2281       {
2282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2283       };
2284     } catch (std::exception& e) {
2285       {
2286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2287       };
2288     } catch (...) {
2289       {
2290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2291       };
2292     }
2293   }
2294   jresult = (void *)result;
2295   return jresult;
2296 }
2297
2298
2299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2300   ushortp *arg1 = (ushortp *) 0 ;
2301
2302   arg1 = (ushortp *)jarg1;
2303   {
2304     try {
2305       delete_ushortp(arg1);
2306     } catch (std::out_of_range& e) {
2307       {
2308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2309       };
2310     } catch (std::exception& e) {
2311       {
2312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2313       };
2314     } catch (...) {
2315       {
2316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2317       };
2318     }
2319   }
2320 }
2321
2322
2323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2324   ushortp *arg1 = (ushortp *) 0 ;
2325   unsigned short arg2 ;
2326
2327   arg1 = (ushortp *)jarg1;
2328   arg2 = (unsigned short)jarg2;
2329   {
2330     try {
2331       ushortp_assign(arg1,arg2);
2332     } catch (std::out_of_range& e) {
2333       {
2334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2335       };
2336     } catch (std::exception& e) {
2337       {
2338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2339       };
2340     } catch (...) {
2341       {
2342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2343       };
2344     }
2345   }
2346 }
2347
2348
2349 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2350   unsigned short jresult ;
2351   ushortp *arg1 = (ushortp *) 0 ;
2352   unsigned short result;
2353
2354   arg1 = (ushortp *)jarg1;
2355   {
2356     try {
2357       result = (unsigned short)ushortp_value(arg1);
2358     } catch (std::out_of_range& e) {
2359       {
2360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2361       };
2362     } catch (std::exception& e) {
2363       {
2364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2365       };
2366     } catch (...) {
2367       {
2368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2369       };
2370     }
2371   }
2372   jresult = result;
2373   return jresult;
2374 }
2375
2376
2377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2378   void * jresult ;
2379   ushortp *arg1 = (ushortp *) 0 ;
2380   unsigned short *result = 0 ;
2381
2382   arg1 = (ushortp *)jarg1;
2383   {
2384     try {
2385       result = (unsigned short *)ushortp_cast(arg1);
2386     } catch (std::out_of_range& e) {
2387       {
2388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2389       };
2390     } catch (std::exception& e) {
2391       {
2392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2393       };
2394     } catch (...) {
2395       {
2396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2397       };
2398     }
2399   }
2400   jresult = (void *)result;
2401   return jresult;
2402 }
2403
2404
2405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2406   void * jresult ;
2407   unsigned short *arg1 = (unsigned short *) 0 ;
2408   ushortp *result = 0 ;
2409
2410   arg1 = (unsigned short *)jarg1;
2411   {
2412     try {
2413       result = (ushortp *)ushortp_frompointer(arg1);
2414     } catch (std::out_of_range& e) {
2415       {
2416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2417       };
2418     } catch (std::exception& e) {
2419       {
2420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2421       };
2422     } catch (...) {
2423       {
2424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2425       };
2426     }
2427   }
2428   jresult = (void *)result;
2429   return jresult;
2430 }
2431
2432
2433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2434   unsigned int jresult ;
2435   int arg1 ;
2436   unsigned int result;
2437
2438   arg1 = (int)jarg1;
2439   {
2440     try {
2441       result = (unsigned int)int_to_uint(arg1);
2442     } catch (std::out_of_range& e) {
2443       {
2444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2445       };
2446     } catch (std::exception& e) {
2447       {
2448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2449       };
2450     } catch (...) {
2451       {
2452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2453       };
2454     }
2455   }
2456   jresult = result;
2457   return jresult;
2458 }
2459
2460
2461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
2462   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2463
2464   arg1 = (Dali::RefObject *)jarg1;
2465   {
2466     try {
2467       (arg1)->Reference();
2468     } catch (std::out_of_range& e) {
2469       {
2470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2471       };
2472     } catch (std::exception& e) {
2473       {
2474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2475       };
2476     } catch (...) {
2477       {
2478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2479       };
2480     }
2481   }
2482 }
2483
2484
2485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
2486   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2487
2488   arg1 = (Dali::RefObject *)jarg1;
2489   {
2490     try {
2491       (arg1)->Unreference();
2492     } catch (std::out_of_range& e) {
2493       {
2494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2495       };
2496     } catch (std::exception& e) {
2497       {
2498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2499       };
2500     } catch (...) {
2501       {
2502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2503       };
2504     }
2505   }
2506 }
2507
2508
2509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
2510   int jresult ;
2511   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2512   int result;
2513
2514   arg1 = (Dali::RefObject *)jarg1;
2515   {
2516     try {
2517       result = (int)(arg1)->ReferenceCount();
2518     } catch (std::out_of_range& e) {
2519       {
2520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2521       };
2522     } catch (std::exception& e) {
2523       {
2524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2525       };
2526     } catch (...) {
2527       {
2528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2529       };
2530     }
2531   }
2532   jresult = result;
2533   return jresult;
2534 }
2535
2536
2537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
2538   void * jresult ;
2539   Dali::Any *result = 0 ;
2540
2541   {
2542     try {
2543       result = (Dali::Any *)new Dali::Any();
2544     } catch (std::out_of_range& e) {
2545       {
2546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2547       };
2548     } catch (std::exception& e) {
2549       {
2550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2551       };
2552     } catch (...) {
2553       {
2554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2555       };
2556     }
2557   }
2558   jresult = (void *)result;
2559   return jresult;
2560 }
2561
2562
2563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
2564   Dali::Any *arg1 = (Dali::Any *) 0 ;
2565
2566   arg1 = (Dali::Any *)jarg1;
2567   {
2568     try {
2569       delete arg1;
2570     } catch (std::out_of_range& e) {
2571       {
2572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2573       };
2574     } catch (std::exception& e) {
2575       {
2576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2577       };
2578     } catch (...) {
2579       {
2580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2581       };
2582     }
2583   }
2584 }
2585
2586
2587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
2588   char *arg1 = (char *) 0 ;
2589
2590   arg1 = (char *)jarg1;
2591   {
2592     try {
2593       Dali::Any::AssertAlways((char const *)arg1);
2594     } catch (std::out_of_range& e) {
2595       {
2596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2597       };
2598     } catch (std::exception& e) {
2599       {
2600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2601       };
2602     } catch (...) {
2603       {
2604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2605       };
2606     }
2607   }
2608 }
2609
2610
2611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
2612   void * jresult ;
2613   Dali::Any *arg1 = 0 ;
2614   Dali::Any *result = 0 ;
2615
2616   arg1 = (Dali::Any *)jarg1;
2617   if (!arg1) {
2618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2619     return 0;
2620   }
2621   {
2622     try {
2623       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
2624     } catch (std::out_of_range& e) {
2625       {
2626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2627       };
2628     } catch (std::exception& e) {
2629       {
2630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2631       };
2632     } catch (...) {
2633       {
2634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2635       };
2636     }
2637   }
2638   jresult = (void *)result;
2639   return jresult;
2640 }
2641
2642
2643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
2644   void * jresult ;
2645   Dali::Any *arg1 = (Dali::Any *) 0 ;
2646   Dali::Any *arg2 = 0 ;
2647   Dali::Any *result = 0 ;
2648
2649   arg1 = (Dali::Any *)jarg1;
2650   arg2 = (Dali::Any *)jarg2;
2651   if (!arg2) {
2652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2653     return 0;
2654   }
2655   {
2656     try {
2657       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
2658     } catch (std::out_of_range& e) {
2659       {
2660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2661       };
2662     } catch (std::exception& e) {
2663       {
2664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2665       };
2666     } catch (...) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2669       };
2670     }
2671   }
2672   jresult = (void *)result;
2673   return jresult;
2674 }
2675
2676
2677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
2678   void * jresult ;
2679   Dali::Any *arg1 = (Dali::Any *) 0 ;
2680   std::type_info *result = 0 ;
2681
2682   arg1 = (Dali::Any *)jarg1;
2683   {
2684     try {
2685       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
2686     } catch (std::out_of_range& e) {
2687       {
2688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2689       };
2690     } catch (std::exception& e) {
2691       {
2692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2693       };
2694     } catch (...) {
2695       {
2696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2697       };
2698     }
2699   }
2700   jresult = (void *)result;
2701   return jresult;
2702 }
2703
2704
2705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
2706   unsigned int jresult ;
2707   Dali::Any *arg1 = (Dali::Any *) 0 ;
2708   bool result;
2709
2710   arg1 = (Dali::Any *)jarg1;
2711   {
2712     try {
2713       result = (bool)((Dali::Any const *)arg1)->Empty();
2714     } catch (std::out_of_range& e) {
2715       {
2716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2717       };
2718     } catch (std::exception& e) {
2719       {
2720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2721       };
2722     } catch (...) {
2723       {
2724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2725       };
2726     }
2727   }
2728   jresult = result;
2729   return jresult;
2730 }
2731
2732
2733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
2734   void * jresult ;
2735   std::type_info *arg1 = 0 ;
2736   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
2737   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
2738   Dali::Any::AnyContainerBase *result = 0 ;
2739
2740   arg1 = (std::type_info *)jarg1;
2741   if (!arg1) {
2742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
2743     return 0;
2744   }
2745   arg2 = (Dali::Any::CloneFunc)jarg2;
2746   arg3 = (Dali::Any::DeleteFunc)jarg3;
2747   {
2748     try {
2749       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
2750     } catch (std::out_of_range& e) {
2751       {
2752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2753       };
2754     } catch (std::exception& e) {
2755       {
2756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (...) {
2759       {
2760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2761       };
2762     }
2763   }
2764   jresult = (void *)result;
2765   return jresult;
2766 }
2767
2768
2769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
2770   void * jresult ;
2771   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2772   std::type_info *result = 0 ;
2773
2774   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2775   {
2776     try {
2777       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
2778     } catch (std::out_of_range& e) {
2779       {
2780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2781       };
2782     } catch (std::exception& e) {
2783       {
2784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2785       };
2786     } catch (...) {
2787       {
2788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2789       };
2790     }
2791   }
2792   jresult = (void *)result;
2793   return jresult;
2794 }
2795
2796
2797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
2798   void * jresult ;
2799   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2800   ::std::type_info *result = 0 ;
2801
2802   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2803   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
2804   jresult = (void *)result;
2805   return jresult;
2806 }
2807
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
2810   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2811   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
2812
2813   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2814   arg2 = (Dali::Any::CloneFunc)jarg2;
2815   if (arg1) (arg1)->mCloneFunc = arg2;
2816 }
2817
2818
2819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
2820   void * jresult ;
2821   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2822   Dali::Any::CloneFunc result;
2823
2824   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2825   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
2826   jresult = (void *)result;
2827   return jresult;
2828 }
2829
2830
2831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
2832   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2833   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
2834
2835   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2836   arg2 = (Dali::Any::DeleteFunc)jarg2;
2837   if (arg1) (arg1)->mDeleteFunc = arg2;
2838 }
2839
2840
2841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
2842   void * jresult ;
2843   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2844   Dali::Any::DeleteFunc result;
2845
2846   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2847   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
2848   jresult = (void *)result;
2849   return jresult;
2850 }
2851
2852
2853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
2854   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2855
2856   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2857   {
2858     try {
2859       delete arg1;
2860     } catch (std::out_of_range& e) {
2861       {
2862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2863       };
2864     } catch (std::exception& e) {
2865       {
2866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2867       };
2868     } catch (...) {
2869       {
2870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2871       };
2872     }
2873   }
2874 }
2875
2876
2877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
2878   Dali::Any *arg1 = (Dali::Any *) 0 ;
2879   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
2880
2881   arg1 = (Dali::Any *)jarg1;
2882   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
2883   if (arg1) (arg1)->mContainer = arg2;
2884 }
2885
2886
2887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
2888   void * jresult ;
2889   Dali::Any *arg1 = (Dali::Any *) 0 ;
2890   Dali::Any::AnyContainerBase *result = 0 ;
2891
2892   arg1 = (Dali::Any *)jarg1;
2893   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
2894   jresult = (void *)result;
2895   return jresult;
2896 }
2897
2898
2899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
2900   void * jresult ;
2901   Dali::Vector2 *result = 0 ;
2902
2903   {
2904     try {
2905       result = (Dali::Vector2 *)new Dali::Vector2();
2906     } catch (std::out_of_range& e) {
2907       {
2908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2909       };
2910     } catch (std::exception& e) {
2911       {
2912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2913       };
2914     } catch (...) {
2915       {
2916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2917       };
2918     }
2919   }
2920   jresult = (void *)result;
2921   return jresult;
2922 }
2923
2924
2925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
2926   void * jresult ;
2927   float arg1 ;
2928   float arg2 ;
2929   Dali::Vector2 *result = 0 ;
2930
2931   arg1 = (float)jarg1;
2932   arg2 = (float)jarg2;
2933   {
2934     try {
2935       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
2936     } catch (std::out_of_range& e) {
2937       {
2938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2939       };
2940     } catch (std::exception& e) {
2941       {
2942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2943       };
2944     } catch (...) {
2945       {
2946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2947       };
2948     }
2949   }
2950   jresult = (void *)result;
2951   return jresult;
2952 }
2953
2954
2955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
2956   void * jresult ;
2957   float *arg1 = (float *) 0 ;
2958   Dali::Vector2 *result = 0 ;
2959
2960   arg1 = jarg1;
2961   {
2962     try {
2963       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
2964     } catch (std::out_of_range& e) {
2965       {
2966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2967       };
2968     } catch (std::exception& e) {
2969       {
2970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2971       };
2972     } catch (...) {
2973       {
2974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2975       };
2976     }
2977   }
2978   jresult = (void *)result;
2979
2980
2981   return jresult;
2982 }
2983
2984
2985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
2986   void * jresult ;
2987   Dali::Vector3 *arg1 = 0 ;
2988   Dali::Vector2 *result = 0 ;
2989
2990   arg1 = (Dali::Vector3 *)jarg1;
2991   if (!arg1) {
2992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
2993     return 0;
2994   }
2995   {
2996     try {
2997       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
2998     } catch (std::out_of_range& e) {
2999       {
3000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3001       };
3002     } catch (std::exception& e) {
3003       {
3004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3005       };
3006     } catch (...) {
3007       {
3008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3009       };
3010     }
3011   }
3012   jresult = (void *)result;
3013   return jresult;
3014 }
3015
3016
3017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3018   void * jresult ;
3019   Dali::Vector4 *arg1 = 0 ;
3020   Dali::Vector2 *result = 0 ;
3021
3022   arg1 = (Dali::Vector4 *)jarg1;
3023   if (!arg1) {
3024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3025     return 0;
3026   }
3027   {
3028     try {
3029       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3030     } catch (std::out_of_range& e) {
3031       {
3032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3033       };
3034     } catch (std::exception& e) {
3035       {
3036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3037       };
3038     } catch (...) {
3039       {
3040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3041       };
3042     }
3043   }
3044   jresult = (void *)result;
3045   return jresult;
3046 }
3047
3048
3049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3050   void * jresult ;
3051   Dali::Vector2 *result = 0 ;
3052
3053   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3054   jresult = (void *)result;
3055   return jresult;
3056 }
3057
3058
3059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3060   void * jresult ;
3061   Dali::Vector2 *result = 0 ;
3062
3063   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3064   jresult = (void *)result;
3065   return jresult;
3066 }
3067
3068
3069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3070   void * jresult ;
3071   Dali::Vector2 *result = 0 ;
3072
3073   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3074   jresult = (void *)result;
3075   return jresult;
3076 }
3077
3078
3079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3080   void * jresult ;
3081   Dali::Vector2 *result = 0 ;
3082
3083   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3084   jresult = (void *)result;
3085   return jresult;
3086 }
3087
3088
3089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3090   void * jresult ;
3091   Dali::Vector2 *result = 0 ;
3092
3093   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3094   jresult = (void *)result;
3095   return jresult;
3096 }
3097
3098
3099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3100   void * jresult ;
3101   Dali::Vector2 *result = 0 ;
3102
3103   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3104   jresult = (void *)result;
3105   return jresult;
3106 }
3107
3108
3109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3110   void * jresult ;
3111   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3112   float *arg2 = (float *) 0 ;
3113   Dali::Vector2 *result = 0 ;
3114
3115   arg1 = (Dali::Vector2 *)jarg1;
3116   arg2 = jarg2;
3117   {
3118     try {
3119       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3120     } catch (std::out_of_range& e) {
3121       {
3122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3123       };
3124     } catch (std::exception& e) {
3125       {
3126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3127       };
3128     } catch (...) {
3129       {
3130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3131       };
3132     }
3133   }
3134   jresult = (void *)result;
3135
3136
3137   return jresult;
3138 }
3139
3140
3141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3142   void * jresult ;
3143   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3144   Dali::Vector3 *arg2 = 0 ;
3145   Dali::Vector2 *result = 0 ;
3146
3147   arg1 = (Dali::Vector2 *)jarg1;
3148   arg2 = (Dali::Vector3 *)jarg2;
3149   if (!arg2) {
3150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3151     return 0;
3152   }
3153   {
3154     try {
3155       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3156     } catch (std::out_of_range& e) {
3157       {
3158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3159       };
3160     } catch (std::exception& e) {
3161       {
3162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3163       };
3164     } catch (...) {
3165       {
3166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3167       };
3168     }
3169   }
3170   jresult = (void *)result;
3171   return jresult;
3172 }
3173
3174
3175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3176   void * jresult ;
3177   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3178   Dali::Vector4 *arg2 = 0 ;
3179   Dali::Vector2 *result = 0 ;
3180
3181   arg1 = (Dali::Vector2 *)jarg1;
3182   arg2 = (Dali::Vector4 *)jarg2;
3183   if (!arg2) {
3184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3185     return 0;
3186   }
3187   {
3188     try {
3189       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3190     } catch (std::out_of_range& e) {
3191       {
3192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3193       };
3194     } catch (std::exception& e) {
3195       {
3196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3197       };
3198     } catch (...) {
3199       {
3200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3201       };
3202     }
3203   }
3204   jresult = (void *)result;
3205   return jresult;
3206 }
3207
3208
3209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3210   void * jresult ;
3211   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3212   Dali::Vector2 *arg2 = 0 ;
3213   Dali::Vector2 result;
3214
3215   arg1 = (Dali::Vector2 *)jarg1;
3216   arg2 = (Dali::Vector2 *)jarg2;
3217   if (!arg2) {
3218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3219     return 0;
3220   }
3221   {
3222     try {
3223       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3224     } catch (std::out_of_range& e) {
3225       {
3226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3227       };
3228     } catch (std::exception& e) {
3229       {
3230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3231       };
3232     } catch (...) {
3233       {
3234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3235       };
3236     }
3237   }
3238   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3239   return jresult;
3240 }
3241
3242
3243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3244   void * jresult ;
3245   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3246   Dali::Vector2 *arg2 = 0 ;
3247   Dali::Vector2 *result = 0 ;
3248
3249   arg1 = (Dali::Vector2 *)jarg1;
3250   arg2 = (Dali::Vector2 *)jarg2;
3251   if (!arg2) {
3252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3253     return 0;
3254   }
3255   {
3256     try {
3257       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3258     } catch (std::out_of_range& e) {
3259       {
3260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3261       };
3262     } catch (std::exception& e) {
3263       {
3264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3265       };
3266     } catch (...) {
3267       {
3268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3269       };
3270     }
3271   }
3272   jresult = (void *)result;
3273   return jresult;
3274 }
3275
3276
3277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3278   void * jresult ;
3279   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3280   Dali::Vector2 *arg2 = 0 ;
3281   Dali::Vector2 result;
3282
3283   arg1 = (Dali::Vector2 *)jarg1;
3284   arg2 = (Dali::Vector2 *)jarg2;
3285   if (!arg2) {
3286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3287     return 0;
3288   }
3289   {
3290     try {
3291       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3292     } catch (std::out_of_range& e) {
3293       {
3294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3295       };
3296     } catch (std::exception& e) {
3297       {
3298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3299       };
3300     } catch (...) {
3301       {
3302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3303       };
3304     }
3305   }
3306   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3312   void * jresult ;
3313   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3314   Dali::Vector2 *arg2 = 0 ;
3315   Dali::Vector2 *result = 0 ;
3316
3317   arg1 = (Dali::Vector2 *)jarg1;
3318   arg2 = (Dali::Vector2 *)jarg2;
3319   if (!arg2) {
3320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3321     return 0;
3322   }
3323   {
3324     try {
3325       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3326     } catch (std::out_of_range& e) {
3327       {
3328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3329       };
3330     } catch (std::exception& e) {
3331       {
3332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3333       };
3334     } catch (...) {
3335       {
3336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3337       };
3338     }
3339   }
3340   jresult = (void *)result;
3341   return jresult;
3342 }
3343
3344
3345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3346   void * jresult ;
3347   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3348   Dali::Vector2 *arg2 = 0 ;
3349   Dali::Vector2 result;
3350
3351   arg1 = (Dali::Vector2 *)jarg1;
3352   arg2 = (Dali::Vector2 *)jarg2;
3353   if (!arg2) {
3354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3355     return 0;
3356   }
3357   {
3358     try {
3359       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3360     } catch (std::out_of_range& e) {
3361       {
3362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3363       };
3364     } catch (std::exception& e) {
3365       {
3366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3367       };
3368     } catch (...) {
3369       {
3370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3371       };
3372     }
3373   }
3374   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3375   return jresult;
3376 }
3377
3378
3379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3380   void * jresult ;
3381   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3382   float arg2 ;
3383   Dali::Vector2 result;
3384
3385   arg1 = (Dali::Vector2 *)jarg1;
3386   arg2 = (float)jarg2;
3387   {
3388     try {
3389       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3390     } catch (std::out_of_range& e) {
3391       {
3392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3393       };
3394     } catch (std::exception& e) {
3395       {
3396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3397       };
3398     } catch (...) {
3399       {
3400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3401       };
3402     }
3403   }
3404   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3405   return jresult;
3406 }
3407
3408
3409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3410   void * jresult ;
3411   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3412   Dali::Vector2 *arg2 = 0 ;
3413   Dali::Vector2 *result = 0 ;
3414
3415   arg1 = (Dali::Vector2 *)jarg1;
3416   arg2 = (Dali::Vector2 *)jarg2;
3417   if (!arg2) {
3418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3419     return 0;
3420   }
3421   {
3422     try {
3423       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3424     } catch (std::out_of_range& e) {
3425       {
3426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3427       };
3428     } catch (std::exception& e) {
3429       {
3430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3431       };
3432     } catch (...) {
3433       {
3434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3435       };
3436     }
3437   }
3438   jresult = (void *)result;
3439   return jresult;
3440 }
3441
3442
3443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3444   void * jresult ;
3445   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3446   float arg2 ;
3447   Dali::Vector2 *result = 0 ;
3448
3449   arg1 = (Dali::Vector2 *)jarg1;
3450   arg2 = (float)jarg2;
3451   {
3452     try {
3453       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3454     } catch (std::out_of_range& e) {
3455       {
3456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (std::exception& e) {
3459       {
3460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468   jresult = (void *)result;
3469   return jresult;
3470 }
3471
3472
3473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3474   void * jresult ;
3475   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3476   Dali::Vector2 *arg2 = 0 ;
3477   Dali::Vector2 result;
3478
3479   arg1 = (Dali::Vector2 *)jarg1;
3480   arg2 = (Dali::Vector2 *)jarg2;
3481   if (!arg2) {
3482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3483     return 0;
3484   }
3485   {
3486     try {
3487       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3488     } catch (std::out_of_range& e) {
3489       {
3490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3491       };
3492     } catch (std::exception& e) {
3493       {
3494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3495       };
3496     } catch (...) {
3497       {
3498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3499       };
3500     }
3501   }
3502   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3508   void * jresult ;
3509   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3510   float arg2 ;
3511   Dali::Vector2 result;
3512
3513   arg1 = (Dali::Vector2 *)jarg1;
3514   arg2 = (float)jarg2;
3515   {
3516     try {
3517       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3518     } catch (std::out_of_range& e) {
3519       {
3520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3521       };
3522     } catch (std::exception& e) {
3523       {
3524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3525       };
3526     } catch (...) {
3527       {
3528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3529       };
3530     }
3531   }
3532   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3533   return jresult;
3534 }
3535
3536
3537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3538   void * jresult ;
3539   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3540   Dali::Vector2 *arg2 = 0 ;
3541   Dali::Vector2 *result = 0 ;
3542
3543   arg1 = (Dali::Vector2 *)jarg1;
3544   arg2 = (Dali::Vector2 *)jarg2;
3545   if (!arg2) {
3546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3547     return 0;
3548   }
3549   {
3550     try {
3551       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3552     } catch (std::out_of_range& e) {
3553       {
3554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3555       };
3556     } catch (std::exception& e) {
3557       {
3558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3559       };
3560     } catch (...) {
3561       {
3562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3563       };
3564     }
3565   }
3566   jresult = (void *)result;
3567   return jresult;
3568 }
3569
3570
3571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3572   void * jresult ;
3573   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3574   float arg2 ;
3575   Dali::Vector2 *result = 0 ;
3576
3577   arg1 = (Dali::Vector2 *)jarg1;
3578   arg2 = (float)jarg2;
3579   {
3580     try {
3581       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3582     } catch (std::out_of_range& e) {
3583       {
3584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3585       };
3586     } catch (std::exception& e) {
3587       {
3588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3589       };
3590     } catch (...) {
3591       {
3592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3593       };
3594     }
3595   }
3596   jresult = (void *)result;
3597   return jresult;
3598 }
3599
3600
3601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3602   void * jresult ;
3603   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3604   Dali::Vector2 result;
3605
3606   arg1 = (Dali::Vector2 *)jarg1;
3607   {
3608     try {
3609       result = ((Dali::Vector2 const *)arg1)->operator -();
3610     } catch (std::out_of_range& e) {
3611       {
3612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3613       };
3614     } catch (std::exception& e) {
3615       {
3616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3617       };
3618     } catch (...) {
3619       {
3620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3621       };
3622     }
3623   }
3624   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3625   return jresult;
3626 }
3627
3628
3629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3630   unsigned int jresult ;
3631   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3632   Dali::Vector2 *arg2 = 0 ;
3633   bool result;
3634
3635   arg1 = (Dali::Vector2 *)jarg1;
3636   arg2 = (Dali::Vector2 *)jarg2;
3637   if (!arg2) {
3638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3639     return 0;
3640   }
3641   {
3642     try {
3643       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3644     } catch (std::out_of_range& e) {
3645       {
3646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3647       };
3648     } catch (std::exception& e) {
3649       {
3650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3651       };
3652     } catch (...) {
3653       {
3654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3655       };
3656     }
3657   }
3658   jresult = result;
3659   return jresult;
3660 }
3661
3662
3663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3664   unsigned int jresult ;
3665   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3666   Dali::Vector2 *arg2 = 0 ;
3667   bool result;
3668
3669   arg1 = (Dali::Vector2 *)jarg1;
3670   arg2 = (Dali::Vector2 *)jarg2;
3671   if (!arg2) {
3672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3673     return 0;
3674   }
3675   {
3676     try {
3677       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3678     } catch (std::out_of_range& e) {
3679       {
3680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3681       };
3682     } catch (std::exception& e) {
3683       {
3684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3685       };
3686     } catch (...) {
3687       {
3688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3689       };
3690     }
3691   }
3692   jresult = result;
3693   return jresult;
3694 }
3695
3696
3697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3698   float jresult ;
3699   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3700   unsigned int arg2 ;
3701   float *result = 0 ;
3702
3703   arg1 = (Dali::Vector2 *)jarg1;
3704   arg2 = (unsigned int)jarg2;
3705   {
3706     try {
3707       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3708     } catch (std::out_of_range& e) {
3709       {
3710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3711       };
3712     } catch (std::exception& e) {
3713       {
3714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3715       };
3716     } catch (...) {
3717       {
3718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3719       };
3720     }
3721   }
3722   jresult = *result;
3723   return jresult;
3724 }
3725
3726
3727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3728   float jresult ;
3729   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3730   float result;
3731
3732   arg1 = (Dali::Vector2 *)jarg1;
3733   {
3734     try {
3735       result = (float)((Dali::Vector2 const *)arg1)->Length();
3736     } catch (std::out_of_range& e) {
3737       {
3738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3739       };
3740     } catch (std::exception& e) {
3741       {
3742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3743       };
3744     } catch (...) {
3745       {
3746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3747       };
3748     }
3749   }
3750   jresult = result;
3751   return jresult;
3752 }
3753
3754
3755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3756   float jresult ;
3757   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3758   float result;
3759
3760   arg1 = (Dali::Vector2 *)jarg1;
3761   {
3762     try {
3763       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
3764     } catch (std::out_of_range& e) {
3765       {
3766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3767       };
3768     } catch (std::exception& e) {
3769       {
3770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3771       };
3772     } catch (...) {
3773       {
3774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3775       };
3776     }
3777   }
3778   jresult = result;
3779   return jresult;
3780 }
3781
3782
3783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
3784   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3785
3786   arg1 = (Dali::Vector2 *)jarg1;
3787   {
3788     try {
3789       (arg1)->Normalize();
3790     } catch (std::out_of_range& e) {
3791       {
3792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3793       };
3794     } catch (std::exception& e) {
3795       {
3796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3797       };
3798     } catch (...) {
3799       {
3800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3801       };
3802     }
3803   }
3804 }
3805
3806
3807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
3808   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3809   Dali::Vector2 *arg2 = 0 ;
3810   Dali::Vector2 *arg3 = 0 ;
3811
3812   arg1 = (Dali::Vector2 *)jarg1;
3813   arg2 = (Dali::Vector2 *)jarg2;
3814   if (!arg2) {
3815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3816     return ;
3817   }
3818   arg3 = (Dali::Vector2 *)jarg3;
3819   if (!arg3) {
3820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3821     return ;
3822   }
3823   {
3824     try {
3825       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
3826     } catch (std::out_of_range& e) {
3827       {
3828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3829       };
3830     } catch (std::exception& e) {
3831       {
3832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3833       };
3834     } catch (...) {
3835       {
3836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3837       };
3838     }
3839   }
3840 }
3841
3842
3843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
3844   void * jresult ;
3845   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3846   float *result = 0 ;
3847
3848   arg1 = (Dali::Vector2 *)jarg1;
3849   {
3850     try {
3851       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
3852     } catch (std::out_of_range& e) {
3853       {
3854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3855       };
3856     } catch (std::exception& e) {
3857       {
3858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3859       };
3860     } catch (...) {
3861       {
3862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3863       };
3864     }
3865   }
3866   jresult = (void *)result;
3867   return jresult;
3868 }
3869
3870
3871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_x_set(void * jarg1, float jarg2) {
3872   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3873   float arg2 ;
3874
3875   arg1 = (Dali::Vector2 *)jarg1;
3876   arg2 = (float)jarg2;
3877   if (arg1) (arg1)->x = arg2;
3878 }
3879
3880
3881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_x_get(void * jarg1) {
3882   float jresult ;
3883   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3884   float result;
3885
3886   arg1 = (Dali::Vector2 *)jarg1;
3887   result = (float) ((arg1)->x);
3888   jresult = result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_width_set(void * jarg1, float jarg2) {
3894   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3895   float arg2 ;
3896
3897   arg1 = (Dali::Vector2 *)jarg1;
3898   arg2 = (float)jarg2;
3899   if (arg1) (arg1)->width = arg2;
3900 }
3901
3902
3903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_width_get(void * jarg1) {
3904   float jresult ;
3905   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3906   float result;
3907
3908   arg1 = (Dali::Vector2 *)jarg1;
3909   result = (float) ((arg1)->width);
3910   jresult = result;
3911   return jresult;
3912 }
3913
3914
3915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_y_set(void * jarg1, float jarg2) {
3916   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3917   float arg2 ;
3918
3919   arg1 = (Dali::Vector2 *)jarg1;
3920   arg2 = (float)jarg2;
3921   if (arg1) (arg1)->y = arg2;
3922 }
3923
3924
3925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_y_get(void * jarg1) {
3926   float jresult ;
3927   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3928   float result;
3929
3930   arg1 = (Dali::Vector2 *)jarg1;
3931   result = (float) ((arg1)->y);
3932   jresult = result;
3933   return jresult;
3934 }
3935
3936
3937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_height_set(void * jarg1, float jarg2) {
3938   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3939   float arg2 ;
3940
3941   arg1 = (Dali::Vector2 *)jarg1;
3942   arg2 = (float)jarg2;
3943   if (arg1) (arg1)->height = arg2;
3944 }
3945
3946
3947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_height_get(void * jarg1) {
3948   float jresult ;
3949   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3950   float result;
3951
3952   arg1 = (Dali::Vector2 *)jarg1;
3953   result = (float) ((arg1)->height);
3954   jresult = result;
3955   return jresult;
3956 }
3957
3958
3959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
3960   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3961
3962   arg1 = (Dali::Vector2 *)jarg1;
3963   {
3964     try {
3965       delete arg1;
3966     } catch (std::out_of_range& e) {
3967       {
3968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3969       };
3970     } catch (std::exception& e) {
3971       {
3972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3973       };
3974     } catch (...) {
3975       {
3976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3977       };
3978     }
3979   }
3980 }
3981
3982
3983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
3984   void * jresult ;
3985   Dali::Vector2 *arg1 = 0 ;
3986   Dali::Vector2 *arg2 = 0 ;
3987   Dali::Vector2 result;
3988
3989   arg1 = (Dali::Vector2 *)jarg1;
3990   if (!arg1) {
3991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3992     return 0;
3993   }
3994   arg2 = (Dali::Vector2 *)jarg2;
3995   if (!arg2) {
3996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3997     return 0;
3998   }
3999   {
4000     try {
4001       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4002     } catch (std::out_of_range& e) {
4003       {
4004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4005       };
4006     } catch (std::exception& e) {
4007       {
4008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4009       };
4010     } catch (...) {
4011       {
4012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4013       };
4014     }
4015   }
4016   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4017   return jresult;
4018 }
4019
4020
4021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4022   void * jresult ;
4023   Dali::Vector2 *arg1 = 0 ;
4024   Dali::Vector2 *arg2 = 0 ;
4025   Dali::Vector2 result;
4026
4027   arg1 = (Dali::Vector2 *)jarg1;
4028   if (!arg1) {
4029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4030     return 0;
4031   }
4032   arg2 = (Dali::Vector2 *)jarg2;
4033   if (!arg2) {
4034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4035     return 0;
4036   }
4037   {
4038     try {
4039       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4040     } catch (std::out_of_range& e) {
4041       {
4042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4043       };
4044     } catch (std::exception& e) {
4045       {
4046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4047       };
4048     } catch (...) {
4049       {
4050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4051       };
4052     }
4053   }
4054   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4055   return jresult;
4056 }
4057
4058
4059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4060   void * jresult ;
4061   Dali::Vector2 *arg1 = 0 ;
4062   float *arg2 = 0 ;
4063   float *arg3 = 0 ;
4064   float temp2 ;
4065   float temp3 ;
4066   Dali::Vector2 result;
4067
4068   arg1 = (Dali::Vector2 *)jarg1;
4069   if (!arg1) {
4070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4071     return 0;
4072   }
4073   temp2 = (float)jarg2;
4074   arg2 = &temp2;
4075   temp3 = (float)jarg3;
4076   arg3 = &temp3;
4077   {
4078     try {
4079       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4080     } catch (std::out_of_range& e) {
4081       {
4082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4083       };
4084     } catch (std::exception& e) {
4085       {
4086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4087       };
4088     } catch (...) {
4089       {
4090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4091       };
4092     }
4093   }
4094   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4095   return jresult;
4096 }
4097
4098
4099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4100   void * jresult ;
4101   Dali::Vector3 *result = 0 ;
4102
4103   {
4104     try {
4105       result = (Dali::Vector3 *)new Dali::Vector3();
4106     } catch (std::out_of_range& e) {
4107       {
4108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4109       };
4110     } catch (std::exception& e) {
4111       {
4112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4113       };
4114     } catch (...) {
4115       {
4116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4117       };
4118     }
4119   }
4120   jresult = (void *)result;
4121   return jresult;
4122 }
4123
4124
4125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4126   void * jresult ;
4127   float arg1 ;
4128   float arg2 ;
4129   float arg3 ;
4130   Dali::Vector3 *result = 0 ;
4131
4132   arg1 = (float)jarg1;
4133   arg2 = (float)jarg2;
4134   arg3 = (float)jarg3;
4135   {
4136     try {
4137       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4138     } catch (std::out_of_range& e) {
4139       {
4140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4141       };
4142     } catch (std::exception& e) {
4143       {
4144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4145       };
4146     } catch (...) {
4147       {
4148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4149       };
4150     }
4151   }
4152   jresult = (void *)result;
4153   return jresult;
4154 }
4155
4156
4157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
4158   void * jresult ;
4159   float *arg1 = (float *) 0 ;
4160   Dali::Vector3 *result = 0 ;
4161
4162   arg1 = jarg1;
4163   {
4164     try {
4165       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4166     } catch (std::out_of_range& e) {
4167       {
4168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4169       };
4170     } catch (std::exception& e) {
4171       {
4172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4173       };
4174     } catch (...) {
4175       {
4176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4177       };
4178     }
4179   }
4180   jresult = (void *)result;
4181
4182
4183   return jresult;
4184 }
4185
4186
4187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
4188   void * jresult ;
4189   Dali::Vector2 *arg1 = 0 ;
4190   Dali::Vector3 *result = 0 ;
4191
4192   arg1 = (Dali::Vector2 *)jarg1;
4193   if (!arg1) {
4194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4195     return 0;
4196   }
4197   {
4198     try {
4199       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
4200     } catch (std::out_of_range& e) {
4201       {
4202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4203       };
4204     } catch (std::exception& e) {
4205       {
4206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4207       };
4208     } catch (...) {
4209       {
4210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4211       };
4212     }
4213   }
4214   jresult = (void *)result;
4215   return jresult;
4216 }
4217
4218
4219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
4220   void * jresult ;
4221   Dali::Vector4 *arg1 = 0 ;
4222   Dali::Vector3 *result = 0 ;
4223
4224   arg1 = (Dali::Vector4 *)jarg1;
4225   if (!arg1) {
4226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4227     return 0;
4228   }
4229   {
4230     try {
4231       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
4232     } catch (std::out_of_range& e) {
4233       {
4234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4235       };
4236     } catch (std::exception& e) {
4237       {
4238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4239       };
4240     } catch (...) {
4241       {
4242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4243       };
4244     }
4245   }
4246   jresult = (void *)result;
4247   return jresult;
4248 }
4249
4250
4251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
4252   void * jresult ;
4253   Dali::Vector3 *result = 0 ;
4254
4255   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
4256   jresult = (void *)result;
4257   return jresult;
4258 }
4259
4260
4261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
4262   void * jresult ;
4263   Dali::Vector3 *result = 0 ;
4264
4265   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
4266   jresult = (void *)result;
4267   return jresult;
4268 }
4269
4270
4271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
4272   void * jresult ;
4273   Dali::Vector3 *result = 0 ;
4274
4275   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
4276   jresult = (void *)result;
4277   return jresult;
4278 }
4279
4280
4281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
4282   void * jresult ;
4283   Dali::Vector3 *result = 0 ;
4284
4285   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4286   jresult = (void *)result;
4287   return jresult;
4288 }
4289
4290
4291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4292   void * jresult ;
4293   Dali::Vector3 *result = 0 ;
4294
4295   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4296   jresult = (void *)result;
4297   return jresult;
4298 }
4299
4300
4301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4302   void * jresult ;
4303   Dali::Vector3 *result = 0 ;
4304
4305   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4306   jresult = (void *)result;
4307   return jresult;
4308 }
4309
4310
4311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4312   void * jresult ;
4313   Dali::Vector3 *result = 0 ;
4314
4315   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4316   jresult = (void *)result;
4317   return jresult;
4318 }
4319
4320
4321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4322   void * jresult ;
4323   Dali::Vector3 *result = 0 ;
4324
4325   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4326   jresult = (void *)result;
4327   return jresult;
4328 }
4329
4330
4331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4332   void * jresult ;
4333   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4334   float *arg2 = (float *) 0 ;
4335   Dali::Vector3 *result = 0 ;
4336
4337   arg1 = (Dali::Vector3 *)jarg1;
4338   arg2 = jarg2;
4339   {
4340     try {
4341       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4342     } catch (std::out_of_range& e) {
4343       {
4344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (std::exception& e) {
4347       {
4348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4349       };
4350     } catch (...) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4353       };
4354     }
4355   }
4356   jresult = (void *)result;
4357
4358
4359   return jresult;
4360 }
4361
4362
4363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4364   void * jresult ;
4365   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4366   Dali::Vector2 *arg2 = 0 ;
4367   Dali::Vector3 *result = 0 ;
4368
4369   arg1 = (Dali::Vector3 *)jarg1;
4370   arg2 = (Dali::Vector2 *)jarg2;
4371   if (!arg2) {
4372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4373     return 0;
4374   }
4375   {
4376     try {
4377       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4378     } catch (std::out_of_range& e) {
4379       {
4380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4381       };
4382     } catch (std::exception& e) {
4383       {
4384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4385       };
4386     } catch (...) {
4387       {
4388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4389       };
4390     }
4391   }
4392   jresult = (void *)result;
4393   return jresult;
4394 }
4395
4396
4397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4398   void * jresult ;
4399   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4400   Dali::Vector4 *arg2 = 0 ;
4401   Dali::Vector3 *result = 0 ;
4402
4403   arg1 = (Dali::Vector3 *)jarg1;
4404   arg2 = (Dali::Vector4 *)jarg2;
4405   if (!arg2) {
4406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4407     return 0;
4408   }
4409   {
4410     try {
4411       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4412     } catch (std::out_of_range& e) {
4413       {
4414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4415       };
4416     } catch (std::exception& e) {
4417       {
4418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4419       };
4420     } catch (...) {
4421       {
4422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4423       };
4424     }
4425   }
4426   jresult = (void *)result;
4427   return jresult;
4428 }
4429
4430
4431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4432   void * jresult ;
4433   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4434   Dali::Vector3 *arg2 = 0 ;
4435   Dali::Vector3 result;
4436
4437   arg1 = (Dali::Vector3 *)jarg1;
4438   arg2 = (Dali::Vector3 *)jarg2;
4439   if (!arg2) {
4440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4441     return 0;
4442   }
4443   {
4444     try {
4445       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4446     } catch (std::out_of_range& e) {
4447       {
4448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4449       };
4450     } catch (std::exception& e) {
4451       {
4452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4453       };
4454     } catch (...) {
4455       {
4456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4457       };
4458     }
4459   }
4460   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4461   return jresult;
4462 }
4463
4464
4465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4466   void * jresult ;
4467   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4468   Dali::Vector3 *arg2 = 0 ;
4469   Dali::Vector3 *result = 0 ;
4470
4471   arg1 = (Dali::Vector3 *)jarg1;
4472   arg2 = (Dali::Vector3 *)jarg2;
4473   if (!arg2) {
4474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4475     return 0;
4476   }
4477   {
4478     try {
4479       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4480     } catch (std::out_of_range& e) {
4481       {
4482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4483       };
4484     } catch (std::exception& e) {
4485       {
4486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4487       };
4488     } catch (...) {
4489       {
4490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4491       };
4492     }
4493   }
4494   jresult = (void *)result;
4495   return jresult;
4496 }
4497
4498
4499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4500   void * jresult ;
4501   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4502   Dali::Vector3 *arg2 = 0 ;
4503   Dali::Vector3 result;
4504
4505   arg1 = (Dali::Vector3 *)jarg1;
4506   arg2 = (Dali::Vector3 *)jarg2;
4507   if (!arg2) {
4508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4509     return 0;
4510   }
4511   {
4512     try {
4513       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4514     } catch (std::out_of_range& e) {
4515       {
4516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4517       };
4518     } catch (std::exception& e) {
4519       {
4520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4521       };
4522     } catch (...) {
4523       {
4524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4525       };
4526     }
4527   }
4528   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4529   return jresult;
4530 }
4531
4532
4533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4534   void * jresult ;
4535   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4536   Dali::Vector3 *arg2 = 0 ;
4537   Dali::Vector3 *result = 0 ;
4538
4539   arg1 = (Dali::Vector3 *)jarg1;
4540   arg2 = (Dali::Vector3 *)jarg2;
4541   if (!arg2) {
4542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4543     return 0;
4544   }
4545   {
4546     try {
4547       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4548     } catch (std::out_of_range& e) {
4549       {
4550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4551       };
4552     } catch (std::exception& e) {
4553       {
4554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4555       };
4556     } catch (...) {
4557       {
4558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4559       };
4560     }
4561   }
4562   jresult = (void *)result;
4563   return jresult;
4564 }
4565
4566
4567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4568   void * jresult ;
4569   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4570   Dali::Vector3 *arg2 = 0 ;
4571   Dali::Vector3 result;
4572
4573   arg1 = (Dali::Vector3 *)jarg1;
4574   arg2 = (Dali::Vector3 *)jarg2;
4575   if (!arg2) {
4576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4577     return 0;
4578   }
4579   {
4580     try {
4581       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4582     } catch (std::out_of_range& e) {
4583       {
4584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4585       };
4586     } catch (std::exception& e) {
4587       {
4588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4589       };
4590     } catch (...) {
4591       {
4592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4593       };
4594     }
4595   }
4596   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4597   return jresult;
4598 }
4599
4600
4601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4602   void * jresult ;
4603   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4604   float arg2 ;
4605   Dali::Vector3 result;
4606
4607   arg1 = (Dali::Vector3 *)jarg1;
4608   arg2 = (float)jarg2;
4609   {
4610     try {
4611       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4612     } catch (std::out_of_range& e) {
4613       {
4614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4615       };
4616     } catch (std::exception& e) {
4617       {
4618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4619       };
4620     } catch (...) {
4621       {
4622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4623       };
4624     }
4625   }
4626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4627   return jresult;
4628 }
4629
4630
4631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4632   void * jresult ;
4633   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4634   Dali::Vector3 *arg2 = 0 ;
4635   Dali::Vector3 *result = 0 ;
4636
4637   arg1 = (Dali::Vector3 *)jarg1;
4638   arg2 = (Dali::Vector3 *)jarg2;
4639   if (!arg2) {
4640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4641     return 0;
4642   }
4643   {
4644     try {
4645       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4646     } catch (std::out_of_range& e) {
4647       {
4648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4649       };
4650     } catch (std::exception& e) {
4651       {
4652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4653       };
4654     } catch (...) {
4655       {
4656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4657       };
4658     }
4659   }
4660   jresult = (void *)result;
4661   return jresult;
4662 }
4663
4664
4665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4666   void * jresult ;
4667   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4668   float arg2 ;
4669   Dali::Vector3 *result = 0 ;
4670
4671   arg1 = (Dali::Vector3 *)jarg1;
4672   arg2 = (float)jarg2;
4673   {
4674     try {
4675       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4676     } catch (std::out_of_range& e) {
4677       {
4678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4679       };
4680     } catch (std::exception& e) {
4681       {
4682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4683       };
4684     } catch (...) {
4685       {
4686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4687       };
4688     }
4689   }
4690   jresult = (void *)result;
4691   return jresult;
4692 }
4693
4694
4695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4696   void * jresult ;
4697   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4698   Dali::Quaternion *arg2 = 0 ;
4699   Dali::Vector3 *result = 0 ;
4700
4701   arg1 = (Dali::Vector3 *)jarg1;
4702   arg2 = (Dali::Quaternion *)jarg2;
4703   if (!arg2) {
4704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4705     return 0;
4706   }
4707   {
4708     try {
4709       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4710     } catch (std::out_of_range& e) {
4711       {
4712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4713       };
4714     } catch (std::exception& e) {
4715       {
4716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4717       };
4718     } catch (...) {
4719       {
4720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4721       };
4722     }
4723   }
4724   jresult = (void *)result;
4725   return jresult;
4726 }
4727
4728
4729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4730   void * jresult ;
4731   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4732   Dali::Vector3 *arg2 = 0 ;
4733   Dali::Vector3 result;
4734
4735   arg1 = (Dali::Vector3 *)jarg1;
4736   arg2 = (Dali::Vector3 *)jarg2;
4737   if (!arg2) {
4738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4739     return 0;
4740   }
4741   {
4742     try {
4743       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4744     } catch (std::out_of_range& e) {
4745       {
4746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4747       };
4748     } catch (std::exception& e) {
4749       {
4750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4751       };
4752     } catch (...) {
4753       {
4754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4755       };
4756     }
4757   }
4758   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4759   return jresult;
4760 }
4761
4762
4763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4764   void * jresult ;
4765   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4766   float arg2 ;
4767   Dali::Vector3 result;
4768
4769   arg1 = (Dali::Vector3 *)jarg1;
4770   arg2 = (float)jarg2;
4771   {
4772     try {
4773       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4774     } catch (std::out_of_range& e) {
4775       {
4776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4777       };
4778     } catch (std::exception& e) {
4779       {
4780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4781       };
4782     } catch (...) {
4783       {
4784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4785       };
4786     }
4787   }
4788   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4789   return jresult;
4790 }
4791
4792
4793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4794   void * jresult ;
4795   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4796   Dali::Vector3 *arg2 = 0 ;
4797   Dali::Vector3 *result = 0 ;
4798
4799   arg1 = (Dali::Vector3 *)jarg1;
4800   arg2 = (Dali::Vector3 *)jarg2;
4801   if (!arg2) {
4802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4803     return 0;
4804   }
4805   {
4806     try {
4807       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4808     } catch (std::out_of_range& e) {
4809       {
4810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4811       };
4812     } catch (std::exception& e) {
4813       {
4814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4815       };
4816     } catch (...) {
4817       {
4818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4819       };
4820     }
4821   }
4822   jresult = (void *)result;
4823   return jresult;
4824 }
4825
4826
4827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4828   void * jresult ;
4829   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4830   float arg2 ;
4831   Dali::Vector3 *result = 0 ;
4832
4833   arg1 = (Dali::Vector3 *)jarg1;
4834   arg2 = (float)jarg2;
4835   {
4836     try {
4837       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4838     } catch (std::out_of_range& e) {
4839       {
4840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4841       };
4842     } catch (std::exception& e) {
4843       {
4844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4845       };
4846     } catch (...) {
4847       {
4848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4849       };
4850     }
4851   }
4852   jresult = (void *)result;
4853   return jresult;
4854 }
4855
4856
4857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4858   void * jresult ;
4859   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4860   Dali::Vector3 result;
4861
4862   arg1 = (Dali::Vector3 *)jarg1;
4863   {
4864     try {
4865       result = ((Dali::Vector3 const *)arg1)->operator -();
4866     } catch (std::out_of_range& e) {
4867       {
4868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4869       };
4870     } catch (std::exception& e) {
4871       {
4872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4873       };
4874     } catch (...) {
4875       {
4876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4877       };
4878     }
4879   }
4880   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4881   return jresult;
4882 }
4883
4884
4885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4886   unsigned int jresult ;
4887   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4888   Dali::Vector3 *arg2 = 0 ;
4889   bool result;
4890
4891   arg1 = (Dali::Vector3 *)jarg1;
4892   arg2 = (Dali::Vector3 *)jarg2;
4893   if (!arg2) {
4894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4895     return 0;
4896   }
4897   {
4898     try {
4899       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4900     } catch (std::out_of_range& e) {
4901       {
4902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4903       };
4904     } catch (std::exception& e) {
4905       {
4906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4907       };
4908     } catch (...) {
4909       {
4910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4911       };
4912     }
4913   }
4914   jresult = result;
4915   return jresult;
4916 }
4917
4918
4919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4920   unsigned int jresult ;
4921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4922   Dali::Vector3 *arg2 = 0 ;
4923   bool result;
4924
4925   arg1 = (Dali::Vector3 *)jarg1;
4926   arg2 = (Dali::Vector3 *)jarg2;
4927   if (!arg2) {
4928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4929     return 0;
4930   }
4931   {
4932     try {
4933       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4934     } catch (std::out_of_range& e) {
4935       {
4936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4937       };
4938     } catch (std::exception& e) {
4939       {
4940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4941       };
4942     } catch (...) {
4943       {
4944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4945       };
4946     }
4947   }
4948   jresult = result;
4949   return jresult;
4950 }
4951
4952
4953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4954   float jresult ;
4955   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4956   unsigned int arg2 ;
4957   float *result = 0 ;
4958
4959   arg1 = (Dali::Vector3 *)jarg1;
4960   arg2 = (unsigned int)jarg2;
4961   {
4962     try {
4963       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4964     } catch (std::out_of_range& e) {
4965       {
4966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4967       };
4968     } catch (std::exception& e) {
4969       {
4970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4971       };
4972     } catch (...) {
4973       {
4974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4975       };
4976     }
4977   }
4978   jresult = *result;
4979   return jresult;
4980 }
4981
4982
4983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4984   float jresult ;
4985   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4986   Dali::Vector3 *arg2 = 0 ;
4987   float result;
4988
4989   arg1 = (Dali::Vector3 *)jarg1;
4990   arg2 = (Dali::Vector3 *)jarg2;
4991   if (!arg2) {
4992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4993     return 0;
4994   }
4995   {
4996     try {
4997       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4998     } catch (std::out_of_range& e) {
4999       {
5000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5001       };
5002     } catch (std::exception& e) {
5003       {
5004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5005       };
5006     } catch (...) {
5007       {
5008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5009       };
5010     }
5011   }
5012   jresult = result;
5013   return jresult;
5014 }
5015
5016
5017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5018   void * jresult ;
5019   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5020   Dali::Vector3 *arg2 = 0 ;
5021   Dali::Vector3 result;
5022
5023   arg1 = (Dali::Vector3 *)jarg1;
5024   arg2 = (Dali::Vector3 *)jarg2;
5025   if (!arg2) {
5026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5027     return 0;
5028   }
5029   {
5030     try {
5031       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5032     } catch (std::out_of_range& e) {
5033       {
5034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5035       };
5036     } catch (std::exception& e) {
5037       {
5038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5039       };
5040     } catch (...) {
5041       {
5042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5043       };
5044     }
5045   }
5046   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5047   return jresult;
5048 }
5049
5050
5051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5052   float jresult ;
5053   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5054   float result;
5055
5056   arg1 = (Dali::Vector3 *)jarg1;
5057   {
5058     try {
5059       result = (float)((Dali::Vector3 const *)arg1)->Length();
5060     } catch (std::out_of_range& e) {
5061       {
5062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5063       };
5064     } catch (std::exception& e) {
5065       {
5066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5067       };
5068     } catch (...) {
5069       {
5070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5071       };
5072     }
5073   }
5074   jresult = result;
5075   return jresult;
5076 }
5077
5078
5079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5080   float jresult ;
5081   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5082   float result;
5083
5084   arg1 = (Dali::Vector3 *)jarg1;
5085   {
5086     try {
5087       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5088     } catch (std::out_of_range& e) {
5089       {
5090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5091       };
5092     } catch (std::exception& e) {
5093       {
5094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5095       };
5096     } catch (...) {
5097       {
5098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5099       };
5100     }
5101   }
5102   jresult = result;
5103   return jresult;
5104 }
5105
5106
5107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
5108   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5109
5110   arg1 = (Dali::Vector3 *)jarg1;
5111   {
5112     try {
5113       (arg1)->Normalize();
5114     } catch (std::out_of_range& e) {
5115       {
5116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5117       };
5118     } catch (std::exception& e) {
5119       {
5120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5121       };
5122     } catch (...) {
5123       {
5124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5125       };
5126     }
5127   }
5128 }
5129
5130
5131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5132   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5133   Dali::Vector3 *arg2 = 0 ;
5134   Dali::Vector3 *arg3 = 0 ;
5135
5136   arg1 = (Dali::Vector3 *)jarg1;
5137   arg2 = (Dali::Vector3 *)jarg2;
5138   if (!arg2) {
5139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5140     return ;
5141   }
5142   arg3 = (Dali::Vector3 *)jarg3;
5143   if (!arg3) {
5144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5145     return ;
5146   }
5147   {
5148     try {
5149       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
5150     } catch (std::out_of_range& e) {
5151       {
5152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5153       };
5154     } catch (std::exception& e) {
5155       {
5156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5157       };
5158     } catch (...) {
5159       {
5160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5161       };
5162     }
5163   }
5164 }
5165
5166
5167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
5168   void * jresult ;
5169   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5170   float *result = 0 ;
5171
5172   arg1 = (Dali::Vector3 *)jarg1;
5173   {
5174     try {
5175       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
5176     } catch (std::out_of_range& e) {
5177       {
5178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5179       };
5180     } catch (std::exception& e) {
5181       {
5182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5183       };
5184     } catch (...) {
5185       {
5186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5187       };
5188     }
5189   }
5190   jresult = (void *)result;
5191   return jresult;
5192 }
5193
5194
5195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
5196   void * jresult ;
5197   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5198   Dali::Vector2 *result = 0 ;
5199
5200   arg1 = (Dali::Vector3 *)jarg1;
5201   {
5202     try {
5203       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
5204     } catch (std::out_of_range& e) {
5205       {
5206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5207       };
5208     } catch (std::exception& e) {
5209       {
5210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5211       };
5212     } catch (...) {
5213       {
5214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5215       };
5216     }
5217   }
5218   jresult = (void *)result;
5219   return jresult;
5220 }
5221
5222
5223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
5224   void * jresult ;
5225   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5226   Dali::Vector2 *result = 0 ;
5227
5228   arg1 = (Dali::Vector3 *)jarg1;
5229   {
5230     try {
5231       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
5232     } catch (std::out_of_range& e) {
5233       {
5234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5235       };
5236     } catch (std::exception& e) {
5237       {
5238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5239       };
5240     } catch (...) {
5241       {
5242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5243       };
5244     }
5245   }
5246   jresult = (void *)result;
5247   return jresult;
5248 }
5249
5250
5251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_x_set(void * jarg1, float jarg2) {
5252   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5253   float arg2 ;
5254
5255   arg1 = (Dali::Vector3 *)jarg1;
5256   arg2 = (float)jarg2;
5257   if (arg1) (arg1)->x = arg2;
5258 }
5259
5260
5261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_x_get(void * jarg1) {
5262   float jresult ;
5263   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5264   float result;
5265
5266   arg1 = (Dali::Vector3 *)jarg1;
5267   result = (float) ((arg1)->x);
5268   jresult = result;
5269   return jresult;
5270 }
5271
5272
5273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_width_set(void * jarg1, float jarg2) {
5274   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5275   float arg2 ;
5276
5277   arg1 = (Dali::Vector3 *)jarg1;
5278   arg2 = (float)jarg2;
5279   if (arg1) (arg1)->width = arg2;
5280 }
5281
5282
5283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_width_get(void * jarg1) {
5284   float jresult ;
5285   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5286   float result;
5287
5288   arg1 = (Dali::Vector3 *)jarg1;
5289   result = (float) ((arg1)->width);
5290   jresult = result;
5291   return jresult;
5292 }
5293
5294
5295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
5296   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5297   float arg2 ;
5298
5299   arg1 = (Dali::Vector3 *)jarg1;
5300   arg2 = (float)jarg2;
5301   if (arg1) (arg1)->r = arg2;
5302 }
5303
5304
5305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
5306   float jresult ;
5307   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5308   float result;
5309
5310   arg1 = (Dali::Vector3 *)jarg1;
5311   result = (float) ((arg1)->r);
5312   jresult = result;
5313   return jresult;
5314 }
5315
5316
5317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_y_set(void * jarg1, float jarg2) {
5318   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5319   float arg2 ;
5320
5321   arg1 = (Dali::Vector3 *)jarg1;
5322   arg2 = (float)jarg2;
5323   if (arg1) (arg1)->y = arg2;
5324 }
5325
5326
5327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_y_get(void * jarg1) {
5328   float jresult ;
5329   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5330   float result;
5331
5332   arg1 = (Dali::Vector3 *)jarg1;
5333   result = (float) ((arg1)->y);
5334   jresult = result;
5335   return jresult;
5336 }
5337
5338
5339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_height_set(void * jarg1, float jarg2) {
5340   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5341   float arg2 ;
5342
5343   arg1 = (Dali::Vector3 *)jarg1;
5344   arg2 = (float)jarg2;
5345   if (arg1) (arg1)->height = arg2;
5346 }
5347
5348
5349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_height_get(void * jarg1) {
5350   float jresult ;
5351   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5352   float result;
5353
5354   arg1 = (Dali::Vector3 *)jarg1;
5355   result = (float) ((arg1)->height);
5356   jresult = result;
5357   return jresult;
5358 }
5359
5360
5361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
5362   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5363   float arg2 ;
5364
5365   arg1 = (Dali::Vector3 *)jarg1;
5366   arg2 = (float)jarg2;
5367   if (arg1) (arg1)->g = arg2;
5368 }
5369
5370
5371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
5372   float jresult ;
5373   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5374   float result;
5375
5376   arg1 = (Dali::Vector3 *)jarg1;
5377   result = (float) ((arg1)->g);
5378   jresult = result;
5379   return jresult;
5380 }
5381
5382
5383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_z_set(void * jarg1, float jarg2) {
5384   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5385   float arg2 ;
5386
5387   arg1 = (Dali::Vector3 *)jarg1;
5388   arg2 = (float)jarg2;
5389   if (arg1) (arg1)->z = arg2;
5390 }
5391
5392
5393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_z_get(void * jarg1) {
5394   float jresult ;
5395   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5396   float result;
5397
5398   arg1 = (Dali::Vector3 *)jarg1;
5399   result = (float) ((arg1)->z);
5400   jresult = result;
5401   return jresult;
5402 }
5403
5404
5405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_depth_set(void * jarg1, float jarg2) {
5406   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5407   float arg2 ;
5408
5409   arg1 = (Dali::Vector3 *)jarg1;
5410   arg2 = (float)jarg2;
5411   if (arg1) (arg1)->depth = arg2;
5412 }
5413
5414
5415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_depth_get(void * jarg1) {
5416   float jresult ;
5417   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5418   float result;
5419
5420   arg1 = (Dali::Vector3 *)jarg1;
5421   result = (float) ((arg1)->depth);
5422   jresult = result;
5423   return jresult;
5424 }
5425
5426
5427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
5428   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5429   float arg2 ;
5430
5431   arg1 = (Dali::Vector3 *)jarg1;
5432   arg2 = (float)jarg2;
5433   if (arg1) (arg1)->b = arg2;
5434 }
5435
5436
5437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
5438   float jresult ;
5439   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5440   float result;
5441
5442   arg1 = (Dali::Vector3 *)jarg1;
5443   result = (float) ((arg1)->b);
5444   jresult = result;
5445   return jresult;
5446 }
5447
5448
5449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
5450   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5451
5452   arg1 = (Dali::Vector3 *)jarg1;
5453   {
5454     try {
5455       delete arg1;
5456     } catch (std::out_of_range& e) {
5457       {
5458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5459       };
5460     } catch (std::exception& e) {
5461       {
5462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5463       };
5464     } catch (...) {
5465       {
5466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5467       };
5468     }
5469   }
5470 }
5471
5472
5473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
5474   void * jresult ;
5475   Dali::Vector3 *arg1 = 0 ;
5476   Dali::Vector3 *arg2 = 0 ;
5477   Dali::Vector3 result;
5478
5479   arg1 = (Dali::Vector3 *)jarg1;
5480   if (!arg1) {
5481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5482     return 0;
5483   }
5484   arg2 = (Dali::Vector3 *)jarg2;
5485   if (!arg2) {
5486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5487     return 0;
5488   }
5489   {
5490     try {
5491       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5492     } catch (std::out_of_range& e) {
5493       {
5494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5495       };
5496     } catch (std::exception& e) {
5497       {
5498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5499       };
5500     } catch (...) {
5501       {
5502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5503       };
5504     }
5505   }
5506   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5507   return jresult;
5508 }
5509
5510
5511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
5512   void * jresult ;
5513   Dali::Vector3 *arg1 = 0 ;
5514   Dali::Vector3 *arg2 = 0 ;
5515   Dali::Vector3 result;
5516
5517   arg1 = (Dali::Vector3 *)jarg1;
5518   if (!arg1) {
5519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5520     return 0;
5521   }
5522   arg2 = (Dali::Vector3 *)jarg2;
5523   if (!arg2) {
5524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5525     return 0;
5526   }
5527   {
5528     try {
5529       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5530     } catch (std::out_of_range& e) {
5531       {
5532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5533       };
5534     } catch (std::exception& e) {
5535       {
5536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5537       };
5538     } catch (...) {
5539       {
5540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5541       };
5542     }
5543   }
5544   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5545   return jresult;
5546 }
5547
5548
5549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
5550   void * jresult ;
5551   Dali::Vector3 *arg1 = 0 ;
5552   float *arg2 = 0 ;
5553   float *arg3 = 0 ;
5554   float temp2 ;
5555   float temp3 ;
5556   Dali::Vector3 result;
5557
5558   arg1 = (Dali::Vector3 *)jarg1;
5559   if (!arg1) {
5560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5561     return 0;
5562   }
5563   temp2 = (float)jarg2;
5564   arg2 = &temp2;
5565   temp3 = (float)jarg3;
5566   arg3 = &temp3;
5567   {
5568     try {
5569       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5570     } catch (std::out_of_range& e) {
5571       {
5572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5573       };
5574     } catch (std::exception& e) {
5575       {
5576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5577       };
5578     } catch (...) {
5579       {
5580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5581       };
5582     }
5583   }
5584   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
5590   void * jresult ;
5591   Dali::Vector4 *result = 0 ;
5592
5593   {
5594     try {
5595       result = (Dali::Vector4 *)new Dali::Vector4();
5596     } catch (std::out_of_range& e) {
5597       {
5598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5599       };
5600     } catch (std::exception& e) {
5601       {
5602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (...) {
5605       {
5606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5607       };
5608     }
5609   }
5610   jresult = (void *)result;
5611   return jresult;
5612 }
5613
5614
5615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
5616   void * jresult ;
5617   float arg1 ;
5618   float arg2 ;
5619   float arg3 ;
5620   float arg4 ;
5621   Dali::Vector4 *result = 0 ;
5622
5623   arg1 = (float)jarg1;
5624   arg2 = (float)jarg2;
5625   arg3 = (float)jarg3;
5626   arg4 = (float)jarg4;
5627   {
5628     try {
5629       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
5630     } catch (std::out_of_range& e) {
5631       {
5632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5633       };
5634     } catch (std::exception& e) {
5635       {
5636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5637       };
5638     } catch (...) {
5639       {
5640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5641       };
5642     }
5643   }
5644   jresult = (void *)result;
5645   return jresult;
5646 }
5647
5648
5649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
5650   void * jresult ;
5651   float *arg1 = (float *) 0 ;
5652   Dali::Vector4 *result = 0 ;
5653
5654   arg1 = jarg1;
5655   {
5656     try {
5657       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
5658     } catch (std::out_of_range& e) {
5659       {
5660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5661       };
5662     } catch (std::exception& e) {
5663       {
5664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5665       };
5666     } catch (...) {
5667       {
5668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5669       };
5670     }
5671   }
5672   jresult = (void *)result;
5673
5674
5675   return jresult;
5676 }
5677
5678
5679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5680   void * jresult ;
5681   Dali::Vector2 *arg1 = 0 ;
5682   Dali::Vector4 *result = 0 ;
5683
5684   arg1 = (Dali::Vector2 *)jarg1;
5685   if (!arg1) {
5686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5687     return 0;
5688   }
5689   {
5690     try {
5691       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5692     } catch (std::out_of_range& e) {
5693       {
5694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5695       };
5696     } catch (std::exception& e) {
5697       {
5698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5699       };
5700     } catch (...) {
5701       {
5702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5703       };
5704     }
5705   }
5706   jresult = (void *)result;
5707   return jresult;
5708 }
5709
5710
5711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5712   void * jresult ;
5713   Dali::Vector3 *arg1 = 0 ;
5714   Dali::Vector4 *result = 0 ;
5715
5716   arg1 = (Dali::Vector3 *)jarg1;
5717   if (!arg1) {
5718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5719     return 0;
5720   }
5721   {
5722     try {
5723       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5724     } catch (std::out_of_range& e) {
5725       {
5726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5727       };
5728     } catch (std::exception& e) {
5729       {
5730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5731       };
5732     } catch (...) {
5733       {
5734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5735       };
5736     }
5737   }
5738   jresult = (void *)result;
5739   return jresult;
5740 }
5741
5742
5743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5744   void * jresult ;
5745   Dali::Vector4 *result = 0 ;
5746
5747   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5748   jresult = (void *)result;
5749   return jresult;
5750 }
5751
5752
5753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5754   void * jresult ;
5755   Dali::Vector4 *result = 0 ;
5756
5757   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5764   void * jresult ;
5765   Dali::Vector4 *result = 0 ;
5766
5767   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5768   jresult = (void *)result;
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5774   void * jresult ;
5775   Dali::Vector4 *result = 0 ;
5776
5777   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5778   jresult = (void *)result;
5779   return jresult;
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5784   void * jresult ;
5785   Dali::Vector4 *result = 0 ;
5786
5787   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5788   jresult = (void *)result;
5789   return jresult;
5790 }
5791
5792
5793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5794   void * jresult ;
5795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5796   float *arg2 = (float *) 0 ;
5797   Dali::Vector4 *result = 0 ;
5798
5799   arg1 = (Dali::Vector4 *)jarg1;
5800   arg2 = jarg2;
5801   {
5802     try {
5803       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5804     } catch (std::out_of_range& e) {
5805       {
5806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5807       };
5808     } catch (std::exception& e) {
5809       {
5810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5811       };
5812     } catch (...) {
5813       {
5814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5815       };
5816     }
5817   }
5818   jresult = (void *)result;
5819
5820
5821   return jresult;
5822 }
5823
5824
5825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5826   void * jresult ;
5827   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5828   Dali::Vector2 *arg2 = 0 ;
5829   Dali::Vector4 *result = 0 ;
5830
5831   arg1 = (Dali::Vector4 *)jarg1;
5832   arg2 = (Dali::Vector2 *)jarg2;
5833   if (!arg2) {
5834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5835     return 0;
5836   }
5837   {
5838     try {
5839       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5840     } catch (std::out_of_range& e) {
5841       {
5842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5843       };
5844     } catch (std::exception& e) {
5845       {
5846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5847       };
5848     } catch (...) {
5849       {
5850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5851       };
5852     }
5853   }
5854   jresult = (void *)result;
5855   return jresult;
5856 }
5857
5858
5859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5860   void * jresult ;
5861   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5862   Dali::Vector3 *arg2 = 0 ;
5863   Dali::Vector4 *result = 0 ;
5864
5865   arg1 = (Dali::Vector4 *)jarg1;
5866   arg2 = (Dali::Vector3 *)jarg2;
5867   if (!arg2) {
5868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5869     return 0;
5870   }
5871   {
5872     try {
5873       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5874     } catch (std::out_of_range& e) {
5875       {
5876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5877       };
5878     } catch (std::exception& e) {
5879       {
5880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5881       };
5882     } catch (...) {
5883       {
5884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5885       };
5886     }
5887   }
5888   jresult = (void *)result;
5889   return jresult;
5890 }
5891
5892
5893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5894   void * jresult ;
5895   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5896   Dali::Vector4 *arg2 = 0 ;
5897   Dali::Vector4 result;
5898
5899   arg1 = (Dali::Vector4 *)jarg1;
5900   arg2 = (Dali::Vector4 *)jarg2;
5901   if (!arg2) {
5902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5903     return 0;
5904   }
5905   {
5906     try {
5907       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5908     } catch (std::out_of_range& e) {
5909       {
5910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5911       };
5912     } catch (std::exception& e) {
5913       {
5914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5915       };
5916     } catch (...) {
5917       {
5918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5919       };
5920     }
5921   }
5922   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5923   return jresult;
5924 }
5925
5926
5927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5928   void * jresult ;
5929   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5930   Dali::Vector4 *arg2 = 0 ;
5931   Dali::Vector4 *result = 0 ;
5932
5933   arg1 = (Dali::Vector4 *)jarg1;
5934   arg2 = (Dali::Vector4 *)jarg2;
5935   if (!arg2) {
5936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5937     return 0;
5938   }
5939   {
5940     try {
5941       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5942     } catch (std::out_of_range& e) {
5943       {
5944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5945       };
5946     } catch (std::exception& e) {
5947       {
5948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5949       };
5950     } catch (...) {
5951       {
5952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5953       };
5954     }
5955   }
5956   jresult = (void *)result;
5957   return jresult;
5958 }
5959
5960
5961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5962   void * jresult ;
5963   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5964   Dali::Vector4 *arg2 = 0 ;
5965   Dali::Vector4 result;
5966
5967   arg1 = (Dali::Vector4 *)jarg1;
5968   arg2 = (Dali::Vector4 *)jarg2;
5969   if (!arg2) {
5970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5971     return 0;
5972   }
5973   {
5974     try {
5975       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5976     } catch (std::out_of_range& e) {
5977       {
5978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5979       };
5980     } catch (std::exception& e) {
5981       {
5982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5983       };
5984     } catch (...) {
5985       {
5986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5987       };
5988     }
5989   }
5990   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5991   return jresult;
5992 }
5993
5994
5995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5996   void * jresult ;
5997   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5998   Dali::Vector4 *arg2 = 0 ;
5999   Dali::Vector4 *result = 0 ;
6000
6001   arg1 = (Dali::Vector4 *)jarg1;
6002   arg2 = (Dali::Vector4 *)jarg2;
6003   if (!arg2) {
6004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6005     return 0;
6006   }
6007   {
6008     try {
6009       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6010     } catch (std::out_of_range& e) {
6011       {
6012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6013       };
6014     } catch (std::exception& e) {
6015       {
6016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6017       };
6018     } catch (...) {
6019       {
6020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6021       };
6022     }
6023   }
6024   jresult = (void *)result;
6025   return jresult;
6026 }
6027
6028
6029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6030   void * jresult ;
6031   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6032   Dali::Vector4 *arg2 = 0 ;
6033   Dali::Vector4 result;
6034
6035   arg1 = (Dali::Vector4 *)jarg1;
6036   arg2 = (Dali::Vector4 *)jarg2;
6037   if (!arg2) {
6038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6039     return 0;
6040   }
6041   {
6042     try {
6043       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6044     } catch (std::out_of_range& e) {
6045       {
6046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6047       };
6048     } catch (std::exception& e) {
6049       {
6050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6051       };
6052     } catch (...) {
6053       {
6054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6055       };
6056     }
6057   }
6058   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6059   return jresult;
6060 }
6061
6062
6063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6064   void * jresult ;
6065   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6066   float arg2 ;
6067   Dali::Vector4 result;
6068
6069   arg1 = (Dali::Vector4 *)jarg1;
6070   arg2 = (float)jarg2;
6071   {
6072     try {
6073       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6074     } catch (std::out_of_range& e) {
6075       {
6076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6077       };
6078     } catch (std::exception& e) {
6079       {
6080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6081       };
6082     } catch (...) {
6083       {
6084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6085       };
6086     }
6087   }
6088   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6089   return jresult;
6090 }
6091
6092
6093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6094   void * jresult ;
6095   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6096   Dali::Vector4 *arg2 = 0 ;
6097   Dali::Vector4 *result = 0 ;
6098
6099   arg1 = (Dali::Vector4 *)jarg1;
6100   arg2 = (Dali::Vector4 *)jarg2;
6101   if (!arg2) {
6102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6103     return 0;
6104   }
6105   {
6106     try {
6107       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6108     } catch (std::out_of_range& e) {
6109       {
6110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6111       };
6112     } catch (std::exception& e) {
6113       {
6114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6115       };
6116     } catch (...) {
6117       {
6118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6119       };
6120     }
6121   }
6122   jresult = (void *)result;
6123   return jresult;
6124 }
6125
6126
6127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6128   void * jresult ;
6129   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6130   float arg2 ;
6131   Dali::Vector4 *result = 0 ;
6132
6133   arg1 = (Dali::Vector4 *)jarg1;
6134   arg2 = (float)jarg2;
6135   {
6136     try {
6137       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
6138     } catch (std::out_of_range& e) {
6139       {
6140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6141       };
6142     } catch (std::exception& e) {
6143       {
6144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6145       };
6146     } catch (...) {
6147       {
6148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6149       };
6150     }
6151   }
6152   jresult = (void *)result;
6153   return jresult;
6154 }
6155
6156
6157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
6158   void * jresult ;
6159   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6160   Dali::Vector4 *arg2 = 0 ;
6161   Dali::Vector4 result;
6162
6163   arg1 = (Dali::Vector4 *)jarg1;
6164   arg2 = (Dali::Vector4 *)jarg2;
6165   if (!arg2) {
6166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6167     return 0;
6168   }
6169   {
6170     try {
6171       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
6172     } catch (std::out_of_range& e) {
6173       {
6174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6175       };
6176     } catch (std::exception& e) {
6177       {
6178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6179       };
6180     } catch (...) {
6181       {
6182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6183       };
6184     }
6185   }
6186   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
6192   void * jresult ;
6193   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6194   float arg2 ;
6195   Dali::Vector4 result;
6196
6197   arg1 = (Dali::Vector4 *)jarg1;
6198   arg2 = (float)jarg2;
6199   {
6200     try {
6201       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
6202     } catch (std::out_of_range& e) {
6203       {
6204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6205       };
6206     } catch (std::exception& e) {
6207       {
6208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6209       };
6210     } catch (...) {
6211       {
6212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6213       };
6214     }
6215   }
6216   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6217   return jresult;
6218 }
6219
6220
6221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6222   void * jresult ;
6223   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6224   Dali::Vector4 *arg2 = 0 ;
6225   Dali::Vector4 *result = 0 ;
6226
6227   arg1 = (Dali::Vector4 *)jarg1;
6228   arg2 = (Dali::Vector4 *)jarg2;
6229   if (!arg2) {
6230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6231     return 0;
6232   }
6233   {
6234     try {
6235       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
6236     } catch (std::out_of_range& e) {
6237       {
6238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6239       };
6240     } catch (std::exception& e) {
6241       {
6242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6243       };
6244     } catch (...) {
6245       {
6246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6247       };
6248     }
6249   }
6250   jresult = (void *)result;
6251   return jresult;
6252 }
6253
6254
6255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6256   void * jresult ;
6257   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6258   float arg2 ;
6259   Dali::Vector4 *result = 0 ;
6260
6261   arg1 = (Dali::Vector4 *)jarg1;
6262   arg2 = (float)jarg2;
6263   {
6264     try {
6265       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
6266     } catch (std::out_of_range& e) {
6267       {
6268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6269       };
6270     } catch (std::exception& e) {
6271       {
6272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6273       };
6274     } catch (...) {
6275       {
6276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6277       };
6278     }
6279   }
6280   jresult = (void *)result;
6281   return jresult;
6282 }
6283
6284
6285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
6286   void * jresult ;
6287   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6288   Dali::Vector4 result;
6289
6290   arg1 = (Dali::Vector4 *)jarg1;
6291   {
6292     try {
6293       result = ((Dali::Vector4 const *)arg1)->operator -();
6294     } catch (std::out_of_range& e) {
6295       {
6296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6297       };
6298     } catch (std::exception& e) {
6299       {
6300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6301       };
6302     } catch (...) {
6303       {
6304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6305       };
6306     }
6307   }
6308   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6309   return jresult;
6310 }
6311
6312
6313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
6314   unsigned int jresult ;
6315   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6316   Dali::Vector4 *arg2 = 0 ;
6317   bool result;
6318
6319   arg1 = (Dali::Vector4 *)jarg1;
6320   arg2 = (Dali::Vector4 *)jarg2;
6321   if (!arg2) {
6322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6323     return 0;
6324   }
6325   {
6326     try {
6327       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
6328     } catch (std::out_of_range& e) {
6329       {
6330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6331       };
6332     } catch (std::exception& e) {
6333       {
6334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6335       };
6336     } catch (...) {
6337       {
6338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6339       };
6340     }
6341   }
6342   jresult = result;
6343   return jresult;
6344 }
6345
6346
6347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
6348   unsigned int jresult ;
6349   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6350   Dali::Vector4 *arg2 = 0 ;
6351   bool result;
6352
6353   arg1 = (Dali::Vector4 *)jarg1;
6354   arg2 = (Dali::Vector4 *)jarg2;
6355   if (!arg2) {
6356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6357     return 0;
6358   }
6359   {
6360     try {
6361       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
6362     } catch (std::out_of_range& e) {
6363       {
6364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6365       };
6366     } catch (std::exception& e) {
6367       {
6368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6369       };
6370     } catch (...) {
6371       {
6372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6373       };
6374     }
6375   }
6376   jresult = result;
6377   return jresult;
6378 }
6379
6380
6381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6382   float jresult ;
6383   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6384   unsigned int arg2 ;
6385   float *result = 0 ;
6386
6387   arg1 = (Dali::Vector4 *)jarg1;
6388   arg2 = (unsigned int)jarg2;
6389   {
6390     try {
6391       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
6392     } catch (std::out_of_range& e) {
6393       {
6394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6395       };
6396     } catch (std::exception& e) {
6397       {
6398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6399       };
6400     } catch (...) {
6401       {
6402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6403       };
6404     }
6405   }
6406   jresult = *result;
6407   return jresult;
6408 }
6409
6410
6411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
6412   float jresult ;
6413   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6414   Dali::Vector3 *arg2 = 0 ;
6415   float result;
6416
6417   arg1 = (Dali::Vector4 *)jarg1;
6418   arg2 = (Dali::Vector3 *)jarg2;
6419   if (!arg2) {
6420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6421     return 0;
6422   }
6423   {
6424     try {
6425       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6426     } catch (std::out_of_range& e) {
6427       {
6428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6429       };
6430     } catch (std::exception& e) {
6431       {
6432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6433       };
6434     } catch (...) {
6435       {
6436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6437       };
6438     }
6439   }
6440   jresult = result;
6441   return jresult;
6442 }
6443
6444
6445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
6446   float jresult ;
6447   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6448   Dali::Vector4 *arg2 = 0 ;
6449   float result;
6450
6451   arg1 = (Dali::Vector4 *)jarg1;
6452   arg2 = (Dali::Vector4 *)jarg2;
6453   if (!arg2) {
6454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6455     return 0;
6456   }
6457   {
6458     try {
6459       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
6460     } catch (std::out_of_range& e) {
6461       {
6462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6463       };
6464     } catch (std::exception& e) {
6465       {
6466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6467       };
6468     } catch (...) {
6469       {
6470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6471       };
6472     }
6473   }
6474   jresult = result;
6475   return jresult;
6476 }
6477
6478
6479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
6480   float jresult ;
6481   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6482   Dali::Vector4 *arg2 = 0 ;
6483   float result;
6484
6485   arg1 = (Dali::Vector4 *)jarg1;
6486   arg2 = (Dali::Vector4 *)jarg2;
6487   if (!arg2) {
6488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6489     return 0;
6490   }
6491   {
6492     try {
6493       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
6494     } catch (std::out_of_range& e) {
6495       {
6496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6497       };
6498     } catch (std::exception& e) {
6499       {
6500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (...) {
6503       {
6504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6505       };
6506     }
6507   }
6508   jresult = result;
6509   return jresult;
6510 }
6511
6512
6513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
6514   void * jresult ;
6515   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6516   Dali::Vector4 *arg2 = 0 ;
6517   Dali::Vector4 result;
6518
6519   arg1 = (Dali::Vector4 *)jarg1;
6520   arg2 = (Dali::Vector4 *)jarg2;
6521   if (!arg2) {
6522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6523     return 0;
6524   }
6525   {
6526     try {
6527       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
6528     } catch (std::out_of_range& e) {
6529       {
6530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6531       };
6532     } catch (std::exception& e) {
6533       {
6534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6535       };
6536     } catch (...) {
6537       {
6538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6539       };
6540     }
6541   }
6542   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6543   return jresult;
6544 }
6545
6546
6547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
6548   float jresult ;
6549   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6550   float result;
6551
6552   arg1 = (Dali::Vector4 *)jarg1;
6553   {
6554     try {
6555       result = (float)((Dali::Vector4 const *)arg1)->Length();
6556     } catch (std::out_of_range& e) {
6557       {
6558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6559       };
6560     } catch (std::exception& e) {
6561       {
6562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6563       };
6564     } catch (...) {
6565       {
6566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6567       };
6568     }
6569   }
6570   jresult = result;
6571   return jresult;
6572 }
6573
6574
6575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
6576   float jresult ;
6577   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6578   float result;
6579
6580   arg1 = (Dali::Vector4 *)jarg1;
6581   {
6582     try {
6583       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
6584     } catch (std::out_of_range& e) {
6585       {
6586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6587       };
6588     } catch (std::exception& e) {
6589       {
6590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6591       };
6592     } catch (...) {
6593       {
6594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6595       };
6596     }
6597   }
6598   jresult = result;
6599   return jresult;
6600 }
6601
6602
6603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
6604   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6605
6606   arg1 = (Dali::Vector4 *)jarg1;
6607   {
6608     try {
6609       (arg1)->Normalize();
6610     } catch (std::out_of_range& e) {
6611       {
6612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6613       };
6614     } catch (std::exception& e) {
6615       {
6616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6617       };
6618     } catch (...) {
6619       {
6620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6621       };
6622     }
6623   }
6624 }
6625
6626
6627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6628   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6629   Dali::Vector4 *arg2 = 0 ;
6630   Dali::Vector4 *arg3 = 0 ;
6631
6632   arg1 = (Dali::Vector4 *)jarg1;
6633   arg2 = (Dali::Vector4 *)jarg2;
6634   if (!arg2) {
6635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6636     return ;
6637   }
6638   arg3 = (Dali::Vector4 *)jarg3;
6639   if (!arg3) {
6640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6641     return ;
6642   }
6643   {
6644     try {
6645       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
6646     } catch (std::out_of_range& e) {
6647       {
6648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6649       };
6650     } catch (std::exception& e) {
6651       {
6652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6653       };
6654     } catch (...) {
6655       {
6656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6657       };
6658     }
6659   }
6660 }
6661
6662
6663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
6664   void * jresult ;
6665   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6666   float *result = 0 ;
6667
6668   arg1 = (Dali::Vector4 *)jarg1;
6669   {
6670     try {
6671       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
6672     } catch (std::out_of_range& e) {
6673       {
6674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6675       };
6676     } catch (std::exception& e) {
6677       {
6678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6679       };
6680     } catch (...) {
6681       {
6682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6683       };
6684     }
6685   }
6686   jresult = (void *)result;
6687   return jresult;
6688 }
6689
6690
6691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_x_set(void * jarg1, float jarg2) {
6692   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6693   float arg2 ;
6694
6695   arg1 = (Dali::Vector4 *)jarg1;
6696   arg2 = (float)jarg2;
6697   if (arg1) (arg1)->x = arg2;
6698 }
6699
6700
6701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_x_get(void * jarg1) {
6702   float jresult ;
6703   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6704   float result;
6705
6706   arg1 = (Dali::Vector4 *)jarg1;
6707   result = (float) ((arg1)->x);
6708   jresult = result;
6709   return jresult;
6710 }
6711
6712
6713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
6714   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6715   float arg2 ;
6716
6717   arg1 = (Dali::Vector4 *)jarg1;
6718   arg2 = (float)jarg2;
6719   if (arg1) (arg1)->r = arg2;
6720 }
6721
6722
6723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
6724   float jresult ;
6725   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6726   float result;
6727
6728   arg1 = (Dali::Vector4 *)jarg1;
6729   result = (float) ((arg1)->r);
6730   jresult = result;
6731   return jresult;
6732 }
6733
6734
6735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
6736   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6737   float arg2 ;
6738
6739   arg1 = (Dali::Vector4 *)jarg1;
6740   arg2 = (float)jarg2;
6741   if (arg1) (arg1)->s = arg2;
6742 }
6743
6744
6745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
6746   float jresult ;
6747   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6748   float result;
6749
6750   arg1 = (Dali::Vector4 *)jarg1;
6751   result = (float) ((arg1)->s);
6752   jresult = result;
6753   return jresult;
6754 }
6755
6756
6757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_y_set(void * jarg1, float jarg2) {
6758   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6759   float arg2 ;
6760
6761   arg1 = (Dali::Vector4 *)jarg1;
6762   arg2 = (float)jarg2;
6763   if (arg1) (arg1)->y = arg2;
6764 }
6765
6766
6767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_y_get(void * jarg1) {
6768   float jresult ;
6769   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6770   float result;
6771
6772   arg1 = (Dali::Vector4 *)jarg1;
6773   result = (float) ((arg1)->y);
6774   jresult = result;
6775   return jresult;
6776 }
6777
6778
6779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
6780   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6781   float arg2 ;
6782
6783   arg1 = (Dali::Vector4 *)jarg1;
6784   arg2 = (float)jarg2;
6785   if (arg1) (arg1)->g = arg2;
6786 }
6787
6788
6789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
6790   float jresult ;
6791   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6792   float result;
6793
6794   arg1 = (Dali::Vector4 *)jarg1;
6795   result = (float) ((arg1)->g);
6796   jresult = result;
6797   return jresult;
6798 }
6799
6800
6801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
6802   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6803   float arg2 ;
6804
6805   arg1 = (Dali::Vector4 *)jarg1;
6806   arg2 = (float)jarg2;
6807   if (arg1) (arg1)->t = arg2;
6808 }
6809
6810
6811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
6812   float jresult ;
6813   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6814   float result;
6815
6816   arg1 = (Dali::Vector4 *)jarg1;
6817   result = (float) ((arg1)->t);
6818   jresult = result;
6819   return jresult;
6820 }
6821
6822
6823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_z_set(void * jarg1, float jarg2) {
6824   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6825   float arg2 ;
6826
6827   arg1 = (Dali::Vector4 *)jarg1;
6828   arg2 = (float)jarg2;
6829   if (arg1) (arg1)->z = arg2;
6830 }
6831
6832
6833 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_z_get(void * jarg1) {
6834   float jresult ;
6835   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6836   float result;
6837
6838   arg1 = (Dali::Vector4 *)jarg1;
6839   result = (float) ((arg1)->z);
6840   jresult = result;
6841   return jresult;
6842 }
6843
6844
6845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
6846   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6847   float arg2 ;
6848
6849   arg1 = (Dali::Vector4 *)jarg1;
6850   arg2 = (float)jarg2;
6851   if (arg1) (arg1)->b = arg2;
6852 }
6853
6854
6855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
6856   float jresult ;
6857   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6858   float result;
6859
6860   arg1 = (Dali::Vector4 *)jarg1;
6861   result = (float) ((arg1)->b);
6862   jresult = result;
6863   return jresult;
6864 }
6865
6866
6867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
6868   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6869   float arg2 ;
6870
6871   arg1 = (Dali::Vector4 *)jarg1;
6872   arg2 = (float)jarg2;
6873   if (arg1) (arg1)->p = arg2;
6874 }
6875
6876
6877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
6878   float jresult ;
6879   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6880   float result;
6881
6882   arg1 = (Dali::Vector4 *)jarg1;
6883   result = (float) ((arg1)->p);
6884   jresult = result;
6885   return jresult;
6886 }
6887
6888
6889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_w_set(void * jarg1, float jarg2) {
6890   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6891   float arg2 ;
6892
6893   arg1 = (Dali::Vector4 *)jarg1;
6894   arg2 = (float)jarg2;
6895   if (arg1) (arg1)->w = arg2;
6896 }
6897
6898
6899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_w_get(void * jarg1) {
6900   float jresult ;
6901   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6902   float result;
6903
6904   arg1 = (Dali::Vector4 *)jarg1;
6905   result = (float) ((arg1)->w);
6906   jresult = result;
6907   return jresult;
6908 }
6909
6910
6911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
6912   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6913   float arg2 ;
6914
6915   arg1 = (Dali::Vector4 *)jarg1;
6916   arg2 = (float)jarg2;
6917   if (arg1) (arg1)->a = arg2;
6918 }
6919
6920
6921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
6922   float jresult ;
6923   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6924   float result;
6925
6926   arg1 = (Dali::Vector4 *)jarg1;
6927   result = (float) ((arg1)->a);
6928   jresult = result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
6934   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6935   float arg2 ;
6936
6937   arg1 = (Dali::Vector4 *)jarg1;
6938   arg2 = (float)jarg2;
6939   if (arg1) (arg1)->q = arg2;
6940 }
6941
6942
6943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
6944   float jresult ;
6945   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6946   float result;
6947
6948   arg1 = (Dali::Vector4 *)jarg1;
6949   result = (float) ((arg1)->q);
6950   jresult = result;
6951   return jresult;
6952 }
6953
6954
6955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
6956   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6957
6958   arg1 = (Dali::Vector4 *)jarg1;
6959   {
6960     try {
6961       delete arg1;
6962     } catch (std::out_of_range& e) {
6963       {
6964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6965       };
6966     } catch (std::exception& e) {
6967       {
6968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6969       };
6970     } catch (...) {
6971       {
6972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6973       };
6974     }
6975   }
6976 }
6977
6978
6979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
6980   void * jresult ;
6981   Dali::Vector4 *arg1 = 0 ;
6982   Dali::Vector4 *arg2 = 0 ;
6983   Dali::Vector4 result;
6984
6985   arg1 = (Dali::Vector4 *)jarg1;
6986   if (!arg1) {
6987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6988     return 0;
6989   }
6990   arg2 = (Dali::Vector4 *)jarg2;
6991   if (!arg2) {
6992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6993     return 0;
6994   }
6995   {
6996     try {
6997       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6998     } catch (std::out_of_range& e) {
6999       {
7000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7001       };
7002     } catch (std::exception& e) {
7003       {
7004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7005       };
7006     } catch (...) {
7007       {
7008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7009       };
7010     }
7011   }
7012   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7013   return jresult;
7014 }
7015
7016
7017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7018   void * jresult ;
7019   Dali::Vector4 *arg1 = 0 ;
7020   Dali::Vector4 *arg2 = 0 ;
7021   Dali::Vector4 result;
7022
7023   arg1 = (Dali::Vector4 *)jarg1;
7024   if (!arg1) {
7025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7026     return 0;
7027   }
7028   arg2 = (Dali::Vector4 *)jarg2;
7029   if (!arg2) {
7030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7031     return 0;
7032   }
7033   {
7034     try {
7035       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7036     } catch (std::out_of_range& e) {
7037       {
7038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7039       };
7040     } catch (std::exception& e) {
7041       {
7042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7043       };
7044     } catch (...) {
7045       {
7046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7047       };
7048     }
7049   }
7050   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7051   return jresult;
7052 }
7053
7054
7055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7056   void * jresult ;
7057   Dali::Vector4 *arg1 = 0 ;
7058   float *arg2 = 0 ;
7059   float *arg3 = 0 ;
7060   float temp2 ;
7061   float temp3 ;
7062   Dali::Vector4 result;
7063
7064   arg1 = (Dali::Vector4 *)jarg1;
7065   if (!arg1) {
7066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7067     return 0;
7068   }
7069   temp2 = (float)jarg2;
7070   arg2 = &temp2;
7071   temp3 = (float)jarg3;
7072   arg3 = &temp3;
7073   {
7074     try {
7075       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7076     } catch (std::out_of_range& e) {
7077       {
7078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7079       };
7080     } catch (std::exception& e) {
7081       {
7082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7083       };
7084     } catch (...) {
7085       {
7086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7087       };
7088     }
7089   }
7090   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7091   return jresult;
7092 }
7093
7094
7095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
7096   void * jresult ;
7097   Dali::Uint16Pair *result = 0 ;
7098
7099   {
7100     try {
7101       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7102     } catch (std::out_of_range& e) {
7103       {
7104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7105       };
7106     } catch (std::exception& e) {
7107       {
7108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7109       };
7110     } catch (...) {
7111       {
7112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7113       };
7114     }
7115   }
7116   jresult = (void *)result;
7117   return jresult;
7118 }
7119
7120
7121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
7122   void * jresult ;
7123   uint32_t arg1 ;
7124   uint32_t arg2 ;
7125   Dali::Uint16Pair *result = 0 ;
7126
7127   arg1 = (uint32_t)jarg1;
7128   arg2 = (uint32_t)jarg2;
7129   {
7130     try {
7131       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
7132     } catch (std::out_of_range& e) {
7133       {
7134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7135       };
7136     } catch (std::exception& e) {
7137       {
7138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7139       };
7140     } catch (...) {
7141       {
7142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7143       };
7144     }
7145   }
7146   jresult = (void *)result;
7147   return jresult;
7148 }
7149
7150
7151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
7152   void * jresult ;
7153   Dali::Uint16Pair *arg1 = 0 ;
7154   Dali::Uint16Pair *result = 0 ;
7155
7156   arg1 = (Dali::Uint16Pair *)jarg1;
7157   if (!arg1) {
7158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
7159     return 0;
7160   }
7161   {
7162     try {
7163       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
7164     } catch (std::out_of_range& e) {
7165       {
7166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7167       };
7168     } catch (std::exception& e) {
7169       {
7170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7171       };
7172     } catch (...) {
7173       {
7174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7175       };
7176     }
7177   }
7178   jresult = (void *)result;
7179   return jresult;
7180 }
7181
7182
7183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
7184   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7185   uint16_t arg2 ;
7186
7187   arg1 = (Dali::Uint16Pair *)jarg1;
7188   arg2 = (uint16_t)jarg2;
7189   {
7190     try {
7191       (arg1)->SetWidth(arg2);
7192     } catch (std::out_of_range& e) {
7193       {
7194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7195       };
7196     } catch (std::exception& e) {
7197       {
7198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7199       };
7200     } catch (...) {
7201       {
7202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7203       };
7204     }
7205   }
7206 }
7207
7208
7209 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
7210   unsigned short jresult ;
7211   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7212   uint16_t result;
7213
7214   arg1 = (Dali::Uint16Pair *)jarg1;
7215   {
7216     try {
7217       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
7218     } catch (std::out_of_range& e) {
7219       {
7220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7221       };
7222     } catch (std::exception& e) {
7223       {
7224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7225       };
7226     } catch (...) {
7227       {
7228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7229       };
7230     }
7231   }
7232   jresult = result;
7233   return jresult;
7234 }
7235
7236
7237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
7238   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7239   uint16_t arg2 ;
7240
7241   arg1 = (Dali::Uint16Pair *)jarg1;
7242   arg2 = (uint16_t)jarg2;
7243   {
7244     try {
7245       (arg1)->SetHeight(arg2);
7246     } catch (std::out_of_range& e) {
7247       {
7248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7249       };
7250     } catch (std::exception& e) {
7251       {
7252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7253       };
7254     } catch (...) {
7255       {
7256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7257       };
7258     }
7259   }
7260 }
7261
7262
7263 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
7264   unsigned short jresult ;
7265   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7266   uint16_t result;
7267
7268   arg1 = (Dali::Uint16Pair *)jarg1;
7269   {
7270     try {
7271       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
7272     } catch (std::out_of_range& e) {
7273       {
7274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7275       };
7276     } catch (std::exception& e) {
7277       {
7278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7279       };
7280     } catch (...) {
7281       {
7282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7283       };
7284     }
7285   }
7286   jresult = result;
7287   return jresult;
7288 }
7289
7290
7291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
7292   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7293   uint16_t arg2 ;
7294
7295   arg1 = (Dali::Uint16Pair *)jarg1;
7296   arg2 = (uint16_t)jarg2;
7297   {
7298     try {
7299       (arg1)->SetX(arg2);
7300     } catch (std::out_of_range& e) {
7301       {
7302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7303       };
7304     } catch (std::exception& e) {
7305       {
7306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7307       };
7308     } catch (...) {
7309       {
7310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7311       };
7312     }
7313   }
7314 }
7315
7316
7317 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
7318   unsigned short jresult ;
7319   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7320   uint16_t result;
7321
7322   arg1 = (Dali::Uint16Pair *)jarg1;
7323   {
7324     try {
7325       result = ((Dali::Uint16Pair const *)arg1)->GetX();
7326     } catch (std::out_of_range& e) {
7327       {
7328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7329       };
7330     } catch (std::exception& e) {
7331       {
7332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7333       };
7334     } catch (...) {
7335       {
7336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7337       };
7338     }
7339   }
7340   jresult = result;
7341   return jresult;
7342 }
7343
7344
7345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
7346   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7347   uint16_t arg2 ;
7348
7349   arg1 = (Dali::Uint16Pair *)jarg1;
7350   arg2 = (uint16_t)jarg2;
7351   {
7352     try {
7353       (arg1)->SetY(arg2);
7354     } catch (std::out_of_range& e) {
7355       {
7356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7357       };
7358     } catch (std::exception& e) {
7359       {
7360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7361       };
7362     } catch (...) {
7363       {
7364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7365       };
7366     }
7367   }
7368 }
7369
7370
7371 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
7372   unsigned short jresult ;
7373   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7374   uint16_t result;
7375
7376   arg1 = (Dali::Uint16Pair *)jarg1;
7377   {
7378     try {
7379       result = ((Dali::Uint16Pair const *)arg1)->GetY();
7380     } catch (std::out_of_range& e) {
7381       {
7382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7383       };
7384     } catch (std::exception& e) {
7385       {
7386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7387       };
7388     } catch (...) {
7389       {
7390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7391       };
7392     }
7393   }
7394   jresult = result;
7395   return jresult;
7396 }
7397
7398
7399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
7400   void * jresult ;
7401   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7402   Dali::Uint16Pair *arg2 = 0 ;
7403   Dali::Uint16Pair *result = 0 ;
7404
7405   arg1 = (Dali::Uint16Pair *)jarg1;
7406   arg2 = (Dali::Uint16Pair *)jarg2;
7407   if (!arg2) {
7408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
7409     return 0;
7410   }
7411   {
7412     try {
7413       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
7414     } catch (std::out_of_range& e) {
7415       {
7416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7417       };
7418     } catch (std::exception& e) {
7419       {
7420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7421       };
7422     } catch (...) {
7423       {
7424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7425       };
7426     }
7427   }
7428   jresult = (void *)result;
7429   return jresult;
7430 }
7431
7432
7433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
7434   unsigned int jresult ;
7435   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7436   Dali::Uint16Pair *arg2 = 0 ;
7437   bool result;
7438
7439   arg1 = (Dali::Uint16Pair *)jarg1;
7440   arg2 = (Dali::Uint16Pair *)jarg2;
7441   if (!arg2) {
7442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
7443     return 0;
7444   }
7445   {
7446     try {
7447       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
7448     } catch (std::out_of_range& e) {
7449       {
7450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7451       };
7452     } catch (std::exception& e) {
7453       {
7454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7455       };
7456     } catch (...) {
7457       {
7458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7459       };
7460     }
7461   }
7462   jresult = result;
7463   return jresult;
7464 }
7465
7466
7467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
7468   unsigned int jresult ;
7469   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7470   Dali::Uint16Pair *arg2 = 0 ;
7471   bool result;
7472
7473   arg1 = (Dali::Uint16Pair *)jarg1;
7474   arg2 = (Dali::Uint16Pair *)jarg2;
7475   if (!arg2) {
7476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
7477     return 0;
7478   }
7479   {
7480     try {
7481       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
7482     } catch (std::out_of_range& e) {
7483       {
7484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7485       };
7486     } catch (std::exception& e) {
7487       {
7488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7489       };
7490     } catch (...) {
7491       {
7492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7493       };
7494     }
7495   }
7496   jresult = result;
7497   return jresult;
7498 }
7499
7500
7501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
7502   unsigned int jresult ;
7503   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7504   Dali::Uint16Pair *arg2 = 0 ;
7505   bool result;
7506
7507   arg1 = (Dali::Uint16Pair *)jarg1;
7508   arg2 = (Dali::Uint16Pair *)jarg2;
7509   if (!arg2) {
7510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
7511     return 0;
7512   }
7513   {
7514     try {
7515       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
7516     } catch (std::out_of_range& e) {
7517       {
7518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7519       };
7520     } catch (std::exception& e) {
7521       {
7522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7523       };
7524     } catch (...) {
7525       {
7526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7527       };
7528     }
7529   }
7530   jresult = result;
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
7536   unsigned int jresult ;
7537   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7538   Dali::Uint16Pair *arg2 = 0 ;
7539   bool result;
7540
7541   arg1 = (Dali::Uint16Pair *)jarg1;
7542   arg2 = (Dali::Uint16Pair *)jarg2;
7543   if (!arg2) {
7544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
7545     return 0;
7546   }
7547   {
7548     try {
7549       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
7550     } catch (std::out_of_range& e) {
7551       {
7552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7553       };
7554     } catch (std::exception& e) {
7555       {
7556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7557       };
7558     } catch (...) {
7559       {
7560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7561       };
7562     }
7563   }
7564   jresult = result;
7565   return jresult;
7566 }
7567
7568
7569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
7570   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7571
7572   arg1 = (Dali::Uint16Pair *)jarg1;
7573   {
7574     try {
7575       delete arg1;
7576     } catch (std::out_of_range& e) {
7577       {
7578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7579       };
7580     } catch (std::exception& e) {
7581       {
7582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7583       };
7584     } catch (...) {
7585       {
7586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7587       };
7588     }
7589   }
7590 }
7591
7592
7593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
7594   void * jresult ;
7595   Dali::Degree *result = 0 ;
7596
7597   {
7598     try {
7599       result = (Dali::Degree *)new Dali::Degree();
7600     } catch (std::out_of_range& e) {
7601       {
7602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7603       };
7604     } catch (std::exception& e) {
7605       {
7606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7607       };
7608     } catch (...) {
7609       {
7610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7611       };
7612     }
7613   }
7614   jresult = (void *)result;
7615   return jresult;
7616 }
7617
7618
7619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
7620   void * jresult ;
7621   float arg1 ;
7622   Dali::Degree *result = 0 ;
7623
7624   arg1 = (float)jarg1;
7625   {
7626     try {
7627       result = (Dali::Degree *)new Dali::Degree(arg1);
7628     } catch (std::out_of_range& e) {
7629       {
7630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7631       };
7632     } catch (std::exception& e) {
7633       {
7634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7635       };
7636     } catch (...) {
7637       {
7638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7639       };
7640     }
7641   }
7642   jresult = (void *)result;
7643   return jresult;
7644 }
7645
7646
7647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
7648   void * jresult ;
7649   Dali::Radian arg1 ;
7650   Dali::Radian *argp1 ;
7651   Dali::Degree *result = 0 ;
7652
7653   argp1 = (Dali::Radian *)jarg1;
7654   if (!argp1) {
7655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7656     return 0;
7657   }
7658   arg1 = *argp1;
7659   {
7660     try {
7661       result = (Dali::Degree *)new Dali::Degree(arg1);
7662     } catch (std::out_of_range& e) {
7663       {
7664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7665       };
7666     } catch (std::exception& e) {
7667       {
7668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7669       };
7670     } catch (...) {
7671       {
7672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7673       };
7674     }
7675   }
7676   jresult = (void *)result;
7677   return jresult;
7678 }
7679
7680
7681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
7682   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
7683   float arg2 ;
7684
7685   arg1 = (Dali::Degree *)jarg1;
7686   arg2 = (float)jarg2;
7687   if (arg1) (arg1)->degree = arg2;
7688 }
7689
7690
7691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
7692   float jresult ;
7693   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
7694   float result;
7695
7696   arg1 = (Dali::Degree *)jarg1;
7697   result = (float) ((arg1)->degree);
7698   jresult = result;
7699   return jresult;
7700 }
7701
7702
7703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
7704   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
7705
7706   arg1 = (Dali::Degree *)jarg1;
7707   {
7708     try {
7709       delete arg1;
7710     } catch (std::out_of_range& e) {
7711       {
7712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7713       };
7714     } catch (std::exception& e) {
7715       {
7716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7717       };
7718     } catch (...) {
7719       {
7720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7721       };
7722     }
7723   }
7724 }
7725
7726
7727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
7728   void * jresult ;
7729   Dali::Radian *result = 0 ;
7730
7731   result = (Dali::Radian *)&Dali::ANGLE_360;
7732   jresult = (void *)result;
7733   return jresult;
7734 }
7735
7736
7737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
7738   void * jresult ;
7739   Dali::Radian *result = 0 ;
7740
7741   result = (Dali::Radian *)&Dali::ANGLE_315;
7742   jresult = (void *)result;
7743   return jresult;
7744 }
7745
7746
7747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
7748   void * jresult ;
7749   Dali::Radian *result = 0 ;
7750
7751   result = (Dali::Radian *)&Dali::ANGLE_270;
7752   jresult = (void *)result;
7753   return jresult;
7754 }
7755
7756
7757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
7758   void * jresult ;
7759   Dali::Radian *result = 0 ;
7760
7761   result = (Dali::Radian *)&Dali::ANGLE_225;
7762   jresult = (void *)result;
7763   return jresult;
7764 }
7765
7766
7767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
7768   void * jresult ;
7769   Dali::Radian *result = 0 ;
7770
7771   result = (Dali::Radian *)&Dali::ANGLE_180;
7772   jresult = (void *)result;
7773   return jresult;
7774 }
7775
7776
7777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
7778   void * jresult ;
7779   Dali::Radian *result = 0 ;
7780
7781   result = (Dali::Radian *)&Dali::ANGLE_135;
7782   jresult = (void *)result;
7783   return jresult;
7784 }
7785
7786
7787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
7788   void * jresult ;
7789   Dali::Radian *result = 0 ;
7790
7791   result = (Dali::Radian *)&Dali::ANGLE_120;
7792   jresult = (void *)result;
7793   return jresult;
7794 }
7795
7796
7797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
7798   void * jresult ;
7799   Dali::Radian *result = 0 ;
7800
7801   result = (Dali::Radian *)&Dali::ANGLE_90;
7802   jresult = (void *)result;
7803   return jresult;
7804 }
7805
7806
7807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
7808   void * jresult ;
7809   Dali::Radian *result = 0 ;
7810
7811   result = (Dali::Radian *)&Dali::ANGLE_60;
7812   jresult = (void *)result;
7813   return jresult;
7814 }
7815
7816
7817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
7818   void * jresult ;
7819   Dali::Radian *result = 0 ;
7820
7821   result = (Dali::Radian *)&Dali::ANGLE_45;
7822   jresult = (void *)result;
7823   return jresult;
7824 }
7825
7826
7827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
7828   void * jresult ;
7829   Dali::Radian *result = 0 ;
7830
7831   result = (Dali::Radian *)&Dali::ANGLE_30;
7832   jresult = (void *)result;
7833   return jresult;
7834 }
7835
7836
7837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
7838   void * jresult ;
7839   Dali::Radian *result = 0 ;
7840
7841   result = (Dali::Radian *)&Dali::ANGLE_0;
7842   jresult = (void *)result;
7843   return jresult;
7844 }
7845
7846
7847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
7848   unsigned int jresult ;
7849   Dali::Degree *arg1 = 0 ;
7850   Dali::Degree *arg2 = 0 ;
7851   bool result;
7852
7853   arg1 = (Dali::Degree *)jarg1;
7854   if (!arg1) {
7855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
7856     return 0;
7857   }
7858   arg2 = (Dali::Degree *)jarg2;
7859   if (!arg2) {
7860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
7861     return 0;
7862   }
7863   {
7864     try {
7865       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
7866     } catch (std::out_of_range& e) {
7867       {
7868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7869       };
7870     } catch (std::exception& e) {
7871       {
7872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7873       };
7874     } catch (...) {
7875       {
7876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7877       };
7878     }
7879   }
7880   jresult = result;
7881   return jresult;
7882 }
7883
7884
7885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
7886   unsigned int jresult ;
7887   Dali::Degree *arg1 = 0 ;
7888   Dali::Degree *arg2 = 0 ;
7889   bool result;
7890
7891   arg1 = (Dali::Degree *)jarg1;
7892   if (!arg1) {
7893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
7894     return 0;
7895   }
7896   arg2 = (Dali::Degree *)jarg2;
7897   if (!arg2) {
7898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
7899     return 0;
7900   }
7901   {
7902     try {
7903       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
7904     } catch (std::out_of_range& e) {
7905       {
7906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7907       };
7908     } catch (std::exception& e) {
7909       {
7910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7911       };
7912     } catch (...) {
7913       {
7914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7915       };
7916     }
7917   }
7918   jresult = result;
7919   return jresult;
7920 }
7921
7922
7923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
7924   void * jresult ;
7925   Dali::Degree arg1 ;
7926   float arg2 ;
7927   float arg3 ;
7928   Dali::Degree *argp1 ;
7929   Dali::Degree result;
7930
7931   argp1 = (Dali::Degree *)jarg1;
7932   if (!argp1) {
7933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7934     return 0;
7935   }
7936   arg1 = *argp1;
7937   arg2 = (float)jarg2;
7938   arg3 = (float)jarg3;
7939   {
7940     try {
7941       result = Dali::Clamp(arg1,arg2,arg3);
7942     } catch (std::out_of_range& e) {
7943       {
7944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7945       };
7946     } catch (std::exception& e) {
7947       {
7948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7949       };
7950     } catch (...) {
7951       {
7952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7953       };
7954     }
7955   }
7956   jresult = new Dali::Degree((const Dali::Degree &)result);
7957   return jresult;
7958 }
7959
7960
7961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
7962   void * jresult ;
7963   Dali::Radian *result = 0 ;
7964
7965   {
7966     try {
7967       result = (Dali::Radian *)new Dali::Radian();
7968     } catch (std::out_of_range& e) {
7969       {
7970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7971       };
7972     } catch (std::exception& e) {
7973       {
7974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7975       };
7976     } catch (...) {
7977       {
7978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7979       };
7980     }
7981   }
7982   jresult = (void *)result;
7983   return jresult;
7984 }
7985
7986
7987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
7988   void * jresult ;
7989   float arg1 ;
7990   Dali::Radian *result = 0 ;
7991
7992   arg1 = (float)jarg1;
7993   {
7994     try {
7995       result = (Dali::Radian *)new Dali::Radian(arg1);
7996     } catch (std::out_of_range& e) {
7997       {
7998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7999       };
8000     } catch (std::exception& e) {
8001       {
8002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8003       };
8004     } catch (...) {
8005       {
8006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8007       };
8008     }
8009   }
8010   jresult = (void *)result;
8011   return jresult;
8012 }
8013
8014
8015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8016   void * jresult ;
8017   Dali::Degree arg1 ;
8018   Dali::Degree *argp1 ;
8019   Dali::Radian *result = 0 ;
8020
8021   argp1 = (Dali::Degree *)jarg1;
8022   if (!argp1) {
8023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8024     return 0;
8025   }
8026   arg1 = *argp1;
8027   {
8028     try {
8029       result = (Dali::Radian *)new Dali::Radian(arg1);
8030     } catch (std::out_of_range& e) {
8031       {
8032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8033       };
8034     } catch (std::exception& e) {
8035       {
8036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8037       };
8038     } catch (...) {
8039       {
8040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8041       };
8042     }
8043   }
8044   jresult = (void *)result;
8045   return jresult;
8046 }
8047
8048
8049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8050   void * jresult ;
8051   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8052   float arg2 ;
8053   Dali::Radian *result = 0 ;
8054
8055   arg1 = (Dali::Radian *)jarg1;
8056   arg2 = (float)jarg2;
8057   {
8058     try {
8059       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8060     } catch (std::out_of_range& e) {
8061       {
8062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8063       };
8064     } catch (std::exception& e) {
8065       {
8066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8067       };
8068     } catch (...) {
8069       {
8070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8071       };
8072     }
8073   }
8074   jresult = (void *)result;
8075   return jresult;
8076 }
8077
8078
8079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8080   void * jresult ;
8081   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8082   Dali::Degree arg2 ;
8083   Dali::Degree *argp2 ;
8084   Dali::Radian *result = 0 ;
8085
8086   arg1 = (Dali::Radian *)jarg1;
8087   argp2 = (Dali::Degree *)jarg2;
8088   if (!argp2) {
8089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8090     return 0;
8091   }
8092   arg2 = *argp2;
8093   {
8094     try {
8095       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8096     } catch (std::out_of_range& e) {
8097       {
8098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8099       };
8100     } catch (std::exception& e) {
8101       {
8102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8103       };
8104     } catch (...) {
8105       {
8106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8107       };
8108     }
8109   }
8110   jresult = (void *)result;
8111   return jresult;
8112 }
8113
8114
8115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
8116   float jresult ;
8117   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8118   float result;
8119
8120   arg1 = (Dali::Radian *)jarg1;
8121   {
8122     try {
8123       result = (float)((Dali::Radian const *)arg1)->operator float();
8124     } catch (std::out_of_range& e) {
8125       {
8126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8127       };
8128     } catch (std::exception& e) {
8129       {
8130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8131       };
8132     } catch (...) {
8133       {
8134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8135       };
8136     }
8137   }
8138   jresult = result;
8139   return jresult;
8140 }
8141
8142
8143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
8144   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8145   float arg2 ;
8146
8147   arg1 = (Dali::Radian *)jarg1;
8148   arg2 = (float)jarg2;
8149   if (arg1) (arg1)->radian = arg2;
8150 }
8151
8152
8153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
8154   float jresult ;
8155   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8156   float result;
8157
8158   arg1 = (Dali::Radian *)jarg1;
8159   result = (float) ((arg1)->radian);
8160   jresult = result;
8161   return jresult;
8162 }
8163
8164
8165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
8166   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8167
8168   arg1 = (Dali::Radian *)jarg1;
8169   {
8170     try {
8171       delete arg1;
8172     } catch (std::out_of_range& e) {
8173       {
8174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8175       };
8176     } catch (std::exception& e) {
8177       {
8178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8179       };
8180     } catch (...) {
8181       {
8182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8183       };
8184     }
8185   }
8186 }
8187
8188
8189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
8190   unsigned int jresult ;
8191   Dali::Radian arg1 ;
8192   Dali::Radian arg2 ;
8193   Dali::Radian *argp1 ;
8194   Dali::Radian *argp2 ;
8195   bool result;
8196
8197   argp1 = (Dali::Radian *)jarg1;
8198   if (!argp1) {
8199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8200     return 0;
8201   }
8202   arg1 = *argp1;
8203   argp2 = (Dali::Radian *)jarg2;
8204   if (!argp2) {
8205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8206     return 0;
8207   }
8208   arg2 = *argp2;
8209   {
8210     try {
8211       result = (bool)Dali::operator ==(arg1,arg2);
8212     } catch (std::out_of_range& e) {
8213       {
8214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8215       };
8216     } catch (std::exception& e) {
8217       {
8218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8219       };
8220     } catch (...) {
8221       {
8222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8223       };
8224     }
8225   }
8226   jresult = result;
8227   return jresult;
8228 }
8229
8230
8231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
8232   unsigned int jresult ;
8233   Dali::Radian arg1 ;
8234   Dali::Radian arg2 ;
8235   Dali::Radian *argp1 ;
8236   Dali::Radian *argp2 ;
8237   bool result;
8238
8239   argp1 = (Dali::Radian *)jarg1;
8240   if (!argp1) {
8241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8242     return 0;
8243   }
8244   arg1 = *argp1;
8245   argp2 = (Dali::Radian *)jarg2;
8246   if (!argp2) {
8247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8248     return 0;
8249   }
8250   arg2 = *argp2;
8251   {
8252     try {
8253       result = (bool)Dali::operator !=(arg1,arg2);
8254     } catch (std::out_of_range& e) {
8255       {
8256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8257       };
8258     } catch (std::exception& e) {
8259       {
8260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8261       };
8262     } catch (...) {
8263       {
8264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8265       };
8266     }
8267   }
8268   jresult = result;
8269   return jresult;
8270 }
8271
8272
8273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
8274   unsigned int jresult ;
8275   Dali::Radian arg1 ;
8276   Dali::Degree arg2 ;
8277   Dali::Radian *argp1 ;
8278   Dali::Degree *argp2 ;
8279   bool result;
8280
8281   argp1 = (Dali::Radian *)jarg1;
8282   if (!argp1) {
8283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8284     return 0;
8285   }
8286   arg1 = *argp1;
8287   argp2 = (Dali::Degree *)jarg2;
8288   if (!argp2) {
8289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8290     return 0;
8291   }
8292   arg2 = *argp2;
8293   {
8294     try {
8295       result = (bool)Dali::operator ==(arg1,arg2);
8296     } catch (std::out_of_range& e) {
8297       {
8298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8299       };
8300     } catch (std::exception& e) {
8301       {
8302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8303       };
8304     } catch (...) {
8305       {
8306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8307       };
8308     }
8309   }
8310   jresult = result;
8311   return jresult;
8312 }
8313
8314
8315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
8316   unsigned int jresult ;
8317   Dali::Radian arg1 ;
8318   Dali::Degree arg2 ;
8319   Dali::Radian *argp1 ;
8320   Dali::Degree *argp2 ;
8321   bool result;
8322
8323   argp1 = (Dali::Radian *)jarg1;
8324   if (!argp1) {
8325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8326     return 0;
8327   }
8328   arg1 = *argp1;
8329   argp2 = (Dali::Degree *)jarg2;
8330   if (!argp2) {
8331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8332     return 0;
8333   }
8334   arg2 = *argp2;
8335   {
8336     try {
8337       result = (bool)Dali::operator !=(arg1,arg2);
8338     } catch (std::out_of_range& e) {
8339       {
8340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8341       };
8342     } catch (std::exception& e) {
8343       {
8344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8345       };
8346     } catch (...) {
8347       {
8348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8349       };
8350     }
8351   }
8352   jresult = result;
8353   return jresult;
8354 }
8355
8356
8357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
8358   unsigned int jresult ;
8359   Dali::Degree arg1 ;
8360   Dali::Radian arg2 ;
8361   Dali::Degree *argp1 ;
8362   Dali::Radian *argp2 ;
8363   bool result;
8364
8365   argp1 = (Dali::Degree *)jarg1;
8366   if (!argp1) {
8367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8368     return 0;
8369   }
8370   arg1 = *argp1;
8371   argp2 = (Dali::Radian *)jarg2;
8372   if (!argp2) {
8373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8374     return 0;
8375   }
8376   arg2 = *argp2;
8377   {
8378     try {
8379       result = (bool)Dali::operator ==(arg1,arg2);
8380     } catch (std::out_of_range& e) {
8381       {
8382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8383       };
8384     } catch (std::exception& e) {
8385       {
8386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8387       };
8388     } catch (...) {
8389       {
8390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8391       };
8392     }
8393   }
8394   jresult = result;
8395   return jresult;
8396 }
8397
8398
8399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
8400   unsigned int jresult ;
8401   Dali::Degree arg1 ;
8402   Dali::Radian arg2 ;
8403   Dali::Degree *argp1 ;
8404   Dali::Radian *argp2 ;
8405   bool result;
8406
8407   argp1 = (Dali::Degree *)jarg1;
8408   if (!argp1) {
8409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8410     return 0;
8411   }
8412   arg1 = *argp1;
8413   argp2 = (Dali::Radian *)jarg2;
8414   if (!argp2) {
8415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8416     return 0;
8417   }
8418   arg2 = *argp2;
8419   {
8420     try {
8421       result = (bool)Dali::operator !=(arg1,arg2);
8422     } catch (std::out_of_range& e) {
8423       {
8424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8425       };
8426     } catch (std::exception& e) {
8427       {
8428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8429       };
8430     } catch (...) {
8431       {
8432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8433       };
8434     }
8435   }
8436   jresult = result;
8437   return jresult;
8438 }
8439
8440
8441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
8442   unsigned int jresult ;
8443   Dali::Radian arg1 ;
8444   Dali::Radian arg2 ;
8445   Dali::Radian *argp1 ;
8446   Dali::Radian *argp2 ;
8447   bool result;
8448
8449   argp1 = (Dali::Radian *)jarg1;
8450   if (!argp1) {
8451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8452     return 0;
8453   }
8454   arg1 = *argp1;
8455   argp2 = (Dali::Radian *)jarg2;
8456   if (!argp2) {
8457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8458     return 0;
8459   }
8460   arg2 = *argp2;
8461   {
8462     try {
8463       result = (bool)Dali::operator >(arg1,arg2);
8464     } catch (std::out_of_range& e) {
8465       {
8466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8467       };
8468     } catch (std::exception& e) {
8469       {
8470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8471       };
8472     } catch (...) {
8473       {
8474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8475       };
8476     }
8477   }
8478   jresult = result;
8479   return jresult;
8480 }
8481
8482
8483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
8484   unsigned int jresult ;
8485   Dali::Radian arg1 ;
8486   Dali::Degree arg2 ;
8487   Dali::Radian *argp1 ;
8488   Dali::Degree *argp2 ;
8489   bool result;
8490
8491   argp1 = (Dali::Radian *)jarg1;
8492   if (!argp1) {
8493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8494     return 0;
8495   }
8496   arg1 = *argp1;
8497   argp2 = (Dali::Degree *)jarg2;
8498   if (!argp2) {
8499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8500     return 0;
8501   }
8502   arg2 = *argp2;
8503   {
8504     try {
8505       result = (bool)Dali::operator >(arg1,arg2);
8506     } catch (std::out_of_range& e) {
8507       {
8508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8509       };
8510     } catch (std::exception& e) {
8511       {
8512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8513       };
8514     } catch (...) {
8515       {
8516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8517       };
8518     }
8519   }
8520   jresult = result;
8521   return jresult;
8522 }
8523
8524
8525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
8526   unsigned int jresult ;
8527   Dali::Degree arg1 ;
8528   Dali::Radian arg2 ;
8529   Dali::Degree *argp1 ;
8530   Dali::Radian *argp2 ;
8531   bool result;
8532
8533   argp1 = (Dali::Degree *)jarg1;
8534   if (!argp1) {
8535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8536     return 0;
8537   }
8538   arg1 = *argp1;
8539   argp2 = (Dali::Radian *)jarg2;
8540   if (!argp2) {
8541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8542     return 0;
8543   }
8544   arg2 = *argp2;
8545   {
8546     try {
8547       result = (bool)Dali::operator >(arg1,arg2);
8548     } catch (std::out_of_range& e) {
8549       {
8550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8551       };
8552     } catch (std::exception& e) {
8553       {
8554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8555       };
8556     } catch (...) {
8557       {
8558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8559       };
8560     }
8561   }
8562   jresult = result;
8563   return jresult;
8564 }
8565
8566
8567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
8568   unsigned int jresult ;
8569   Dali::Radian arg1 ;
8570   Dali::Radian arg2 ;
8571   Dali::Radian *argp1 ;
8572   Dali::Radian *argp2 ;
8573   bool result;
8574
8575   argp1 = (Dali::Radian *)jarg1;
8576   if (!argp1) {
8577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8578     return 0;
8579   }
8580   arg1 = *argp1;
8581   argp2 = (Dali::Radian *)jarg2;
8582   if (!argp2) {
8583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8584     return 0;
8585   }
8586   arg2 = *argp2;
8587   {
8588     try {
8589       result = (bool)Dali::operator <(arg1,arg2);
8590     } catch (std::out_of_range& e) {
8591       {
8592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8593       };
8594     } catch (std::exception& e) {
8595       {
8596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8597       };
8598     } catch (...) {
8599       {
8600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8601       };
8602     }
8603   }
8604   jresult = result;
8605   return jresult;
8606 }
8607
8608
8609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
8610   unsigned int jresult ;
8611   Dali::Radian arg1 ;
8612   Dali::Degree arg2 ;
8613   Dali::Radian *argp1 ;
8614   Dali::Degree *argp2 ;
8615   bool result;
8616
8617   argp1 = (Dali::Radian *)jarg1;
8618   if (!argp1) {
8619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8620     return 0;
8621   }
8622   arg1 = *argp1;
8623   argp2 = (Dali::Degree *)jarg2;
8624   if (!argp2) {
8625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8626     return 0;
8627   }
8628   arg2 = *argp2;
8629   {
8630     try {
8631       result = (bool)Dali::operator <(arg1,arg2);
8632     } catch (std::out_of_range& e) {
8633       {
8634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8635       };
8636     } catch (std::exception& e) {
8637       {
8638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8639       };
8640     } catch (...) {
8641       {
8642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8643       };
8644     }
8645   }
8646   jresult = result;
8647   return jresult;
8648 }
8649
8650
8651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
8652   unsigned int jresult ;
8653   Dali::Degree arg1 ;
8654   Dali::Radian arg2 ;
8655   Dali::Degree *argp1 ;
8656   Dali::Radian *argp2 ;
8657   bool result;
8658
8659   argp1 = (Dali::Degree *)jarg1;
8660   if (!argp1) {
8661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8662     return 0;
8663   }
8664   arg1 = *argp1;
8665   argp2 = (Dali::Radian *)jarg2;
8666   if (!argp2) {
8667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8668     return 0;
8669   }
8670   arg2 = *argp2;
8671   {
8672     try {
8673       result = (bool)Dali::operator <(arg1,arg2);
8674     } catch (std::out_of_range& e) {
8675       {
8676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8677       };
8678     } catch (std::exception& e) {
8679       {
8680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8681       };
8682     } catch (...) {
8683       {
8684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8685       };
8686     }
8687   }
8688   jresult = result;
8689   return jresult;
8690 }
8691
8692
8693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
8694   void * jresult ;
8695   Dali::Radian arg1 ;
8696   float arg2 ;
8697   Dali::Radian *argp1 ;
8698   Dali::Radian result;
8699
8700   argp1 = (Dali::Radian *)jarg1;
8701   if (!argp1) {
8702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8703     return 0;
8704   }
8705   arg1 = *argp1;
8706   arg2 = (float)jarg2;
8707   {
8708     try {
8709       result = Dali::operator *(arg1,arg2);
8710     } catch (std::out_of_range& e) {
8711       {
8712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8713       };
8714     } catch (std::exception& e) {
8715       {
8716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8717       };
8718     } catch (...) {
8719       {
8720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8721       };
8722     }
8723   }
8724   jresult = new Dali::Radian((const Dali::Radian &)result);
8725   return jresult;
8726 }
8727
8728
8729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
8730   void * jresult ;
8731   Dali::Radian arg1 ;
8732   Dali::Radian *argp1 ;
8733   Dali::Radian result;
8734
8735   argp1 = (Dali::Radian *)jarg1;
8736   if (!argp1) {
8737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8738     return 0;
8739   }
8740   arg1 = *argp1;
8741   {
8742     try {
8743       result = Dali::operator -(arg1);
8744     } catch (std::out_of_range& e) {
8745       {
8746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8747       };
8748     } catch (std::exception& e) {
8749       {
8750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8751       };
8752     } catch (...) {
8753       {
8754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8755       };
8756     }
8757   }
8758   jresult = new Dali::Radian((const Dali::Radian &)result);
8759   return jresult;
8760 }
8761
8762
8763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
8764   void * jresult ;
8765   Dali::Radian arg1 ;
8766   float arg2 ;
8767   float arg3 ;
8768   Dali::Radian *argp1 ;
8769   Dali::Radian result;
8770
8771   argp1 = (Dali::Radian *)jarg1;
8772   if (!argp1) {
8773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8774     return 0;
8775   }
8776   arg1 = *argp1;
8777   arg2 = (float)jarg2;
8778   arg3 = (float)jarg3;
8779   {
8780     try {
8781       result = Dali::Clamp(arg1,arg2,arg3);
8782     } catch (std::out_of_range& e) {
8783       {
8784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8785       };
8786     } catch (std::exception& e) {
8787       {
8788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8789       };
8790     } catch (...) {
8791       {
8792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8793       };
8794     }
8795   }
8796   jresult = new Dali::Radian((const Dali::Radian &)result);
8797   return jresult;
8798 }
8799
8800
8801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_0() {
8802   void * jresult ;
8803   Dali::Quaternion *result = 0 ;
8804
8805   {
8806     try {
8807       result = (Dali::Quaternion *)new Dali::Quaternion();
8808     } catch (std::out_of_range& e) {
8809       {
8810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8811       };
8812     } catch (std::exception& e) {
8813       {
8814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8815       };
8816     } catch (...) {
8817       {
8818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8819       };
8820     }
8821   }
8822   jresult = (void *)result;
8823   return jresult;
8824 }
8825
8826
8827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
8828   void * jresult ;
8829   float arg1 ;
8830   float arg2 ;
8831   float arg3 ;
8832   float arg4 ;
8833   Dali::Quaternion *result = 0 ;
8834
8835   arg1 = (float)jarg1;
8836   arg2 = (float)jarg2;
8837   arg3 = (float)jarg3;
8838   arg4 = (float)jarg4;
8839   {
8840     try {
8841       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3,arg4);
8842     } catch (std::out_of_range& e) {
8843       {
8844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8845       };
8846     } catch (std::exception& e) {
8847       {
8848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (...) {
8851       {
8852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8853       };
8854     }
8855   }
8856   jresult = (void *)result;
8857   return jresult;
8858 }
8859
8860
8861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_2(void * jarg1) {
8862   void * jresult ;
8863   Dali::Vector4 *arg1 = 0 ;
8864   Dali::Quaternion *result = 0 ;
8865
8866   arg1 = (Dali::Vector4 *)jarg1;
8867   if (!arg1) {
8868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8869     return 0;
8870   }
8871   {
8872     try {
8873       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector4 const &)*arg1);
8874     } catch (std::out_of_range& e) {
8875       {
8876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8877       };
8878     } catch (std::exception& e) {
8879       {
8880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8881       };
8882     } catch (...) {
8883       {
8884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8885       };
8886     }
8887   }
8888   jresult = (void *)result;
8889   return jresult;
8890 }
8891
8892
8893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_3(void * jarg1, void * jarg2) {
8894   void * jresult ;
8895   Dali::Radian arg1 ;
8896   Dali::Vector3 *arg2 = 0 ;
8897   Dali::Radian *argp1 ;
8898   Dali::Quaternion *result = 0 ;
8899
8900   argp1 = (Dali::Radian *)jarg1;
8901   if (!argp1) {
8902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8903     return 0;
8904   }
8905   arg1 = *argp1;
8906   arg2 = (Dali::Vector3 *)jarg2;
8907   if (!arg2) {
8908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8909     return 0;
8910   }
8911   {
8912     try {
8913       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
8914     } catch (std::out_of_range& e) {
8915       {
8916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8917       };
8918     } catch (std::exception& e) {
8919       {
8920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8921       };
8922     } catch (...) {
8923       {
8924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8925       };
8926     }
8927   }
8928   jresult = (void *)result;
8929   return jresult;
8930 }
8931
8932
8933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
8934   void * jresult ;
8935   Dali::Radian arg1 ;
8936   Dali::Radian arg2 ;
8937   Dali::Radian arg3 ;
8938   Dali::Radian *argp1 ;
8939   Dali::Radian *argp2 ;
8940   Dali::Radian *argp3 ;
8941   Dali::Quaternion *result = 0 ;
8942
8943   argp1 = (Dali::Radian *)jarg1;
8944   if (!argp1) {
8945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8946     return 0;
8947   }
8948   arg1 = *argp1;
8949   argp2 = (Dali::Radian *)jarg2;
8950   if (!argp2) {
8951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8952     return 0;
8953   }
8954   arg2 = *argp2;
8955   argp3 = (Dali::Radian *)jarg3;
8956   if (!argp3) {
8957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8958     return 0;
8959   }
8960   arg3 = *argp3;
8961   {
8962     try {
8963       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3);
8964     } catch (std::out_of_range& e) {
8965       {
8966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8967       };
8968     } catch (std::exception& e) {
8969       {
8970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8971       };
8972     } catch (...) {
8973       {
8974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8975       };
8976     }
8977   }
8978   jresult = (void *)result;
8979   return jresult;
8980 }
8981
8982
8983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_5(void * jarg1) {
8984   void * jresult ;
8985   Dali::Matrix *arg1 = 0 ;
8986   Dali::Quaternion *result = 0 ;
8987
8988   arg1 = (Dali::Matrix *)jarg1;
8989   if (!arg1) {
8990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8991     return 0;
8992   }
8993   {
8994     try {
8995       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Matrix const &)*arg1);
8996     } catch (std::out_of_range& e) {
8997       {
8998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8999       };
9000     } catch (std::exception& e) {
9001       {
9002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9003       };
9004     } catch (...) {
9005       {
9006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9007       };
9008     }
9009   }
9010   jresult = (void *)result;
9011   return jresult;
9012 }
9013
9014
9015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_6(void * jarg1, void * jarg2, void * jarg3) {
9016   void * jresult ;
9017   Dali::Vector3 *arg1 = 0 ;
9018   Dali::Vector3 *arg2 = 0 ;
9019   Dali::Vector3 *arg3 = 0 ;
9020   Dali::Quaternion *result = 0 ;
9021
9022   arg1 = (Dali::Vector3 *)jarg1;
9023   if (!arg1) {
9024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9025     return 0;
9026   }
9027   arg2 = (Dali::Vector3 *)jarg2;
9028   if (!arg2) {
9029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9030     return 0;
9031   }
9032   arg3 = (Dali::Vector3 *)jarg3;
9033   if (!arg3) {
9034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9035     return 0;
9036   }
9037   {
9038     try {
9039       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
9040     } catch (std::out_of_range& e) {
9041       {
9042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9043       };
9044     } catch (std::exception& e) {
9045       {
9046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9047       };
9048     } catch (...) {
9049       {
9050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9051       };
9052     }
9053   }
9054   jresult = (void *)result;
9055   return jresult;
9056 }
9057
9058
9059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_7(void * jarg1, void * jarg2) {
9060   void * jresult ;
9061   Dali::Vector3 *arg1 = 0 ;
9062   Dali::Vector3 *arg2 = 0 ;
9063   Dali::Quaternion *result = 0 ;
9064
9065   arg1 = (Dali::Vector3 *)jarg1;
9066   if (!arg1) {
9067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9068     return 0;
9069   }
9070   arg2 = (Dali::Vector3 *)jarg2;
9071   if (!arg2) {
9072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9073     return 0;
9074   }
9075   {
9076     try {
9077       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
9078     } catch (std::out_of_range& e) {
9079       {
9080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9081       };
9082     } catch (std::exception& e) {
9083       {
9084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9085       };
9086     } catch (...) {
9087       {
9088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9089       };
9090     }
9091   }
9092   jresult = (void *)result;
9093   return jresult;
9094 }
9095
9096
9097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Quaternion(void * jarg1) {
9098   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9099
9100   arg1 = (Dali::Quaternion *)jarg1;
9101   {
9102     try {
9103       delete arg1;
9104     } catch (std::out_of_range& e) {
9105       {
9106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9107       };
9108     } catch (std::exception& e) {
9109       {
9110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9111       };
9112     } catch (...) {
9113       {
9114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9115       };
9116     }
9117   }
9118 }
9119
9120
9121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_IDENTITY_get() {
9122   void * jresult ;
9123   Dali::Quaternion *result = 0 ;
9124
9125   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9126   jresult = (void *)result;
9127   return jresult;
9128 }
9129
9130
9131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Quaternion_IsIdentity(void * jarg1) {
9132   unsigned int jresult ;
9133   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9134   bool result;
9135
9136   arg1 = (Dali::Quaternion *)jarg1;
9137   {
9138     try {
9139       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9140     } catch (std::out_of_range& e) {
9141       {
9142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9143       };
9144     } catch (std::exception& e) {
9145       {
9146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9147       };
9148     } catch (...) {
9149       {
9150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9151       };
9152     }
9153   }
9154   jresult = result;
9155   return jresult;
9156 }
9157
9158
9159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Quaternion_ToAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9160   unsigned int jresult ;
9161   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9162   Dali::Vector3 *arg2 = 0 ;
9163   Dali::Radian *arg3 = 0 ;
9164   bool result;
9165
9166   arg1 = (Dali::Quaternion *)jarg1;
9167   arg2 = (Dali::Vector3 *)jarg2;
9168   if (!arg2) {
9169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9170     return 0;
9171   }
9172   arg3 = (Dali::Radian *)jarg3;
9173   if (!arg3) {
9174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9175     return 0;
9176   }
9177   {
9178     try {
9179       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9180     } catch (std::out_of_range& e) {
9181       {
9182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9183       };
9184     } catch (std::exception& e) {
9185       {
9186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9187       };
9188     } catch (...) {
9189       {
9190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9191       };
9192     }
9193   }
9194   jresult = result;
9195   return jresult;
9196 }
9197
9198
9199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_AsVector(void * jarg1) {
9200   void * jresult ;
9201   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9202   Dali::Vector4 *result = 0 ;
9203
9204   arg1 = (Dali::Quaternion *)jarg1;
9205   {
9206     try {
9207       result = (Dali::Vector4 *) &((Dali::Quaternion const *)arg1)->AsVector();
9208     } catch (std::out_of_range& e) {
9209       {
9210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9211       };
9212     } catch (std::exception& e) {
9213       {
9214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9215       };
9216     } catch (...) {
9217       {
9218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9219       };
9220     }
9221   }
9222   jresult = (void *)result;
9223   return jresult;
9224 }
9225
9226
9227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_SetEuler(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
9228   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9229   Dali::Radian arg2 ;
9230   Dali::Radian arg3 ;
9231   Dali::Radian arg4 ;
9232   Dali::Radian *argp2 ;
9233   Dali::Radian *argp3 ;
9234   Dali::Radian *argp4 ;
9235
9236   arg1 = (Dali::Quaternion *)jarg1;
9237   argp2 = (Dali::Radian *)jarg2;
9238   if (!argp2) {
9239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9240     return ;
9241   }
9242   arg2 = *argp2;
9243   argp3 = (Dali::Radian *)jarg3;
9244   if (!argp3) {
9245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9246     return ;
9247   }
9248   arg3 = *argp3;
9249   argp4 = (Dali::Radian *)jarg4;
9250   if (!argp4) {
9251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9252     return ;
9253   }
9254   arg4 = *argp4;
9255   {
9256     try {
9257       (arg1)->SetEuler(arg2,arg3,arg4);
9258     } catch (std::out_of_range& e) {
9259       {
9260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9261       };
9262     } catch (std::exception& e) {
9263       {
9264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9265       };
9266     } catch (...) {
9267       {
9268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9269       };
9270     }
9271   }
9272 }
9273
9274
9275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_EulerAngles(void * jarg1) {
9276   void * jresult ;
9277   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9278   Dali::Vector4 result;
9279
9280   arg1 = (Dali::Quaternion *)jarg1;
9281   {
9282     try {
9283       result = ((Dali::Quaternion const *)arg1)->EulerAngles();
9284     } catch (std::out_of_range& e) {
9285       {
9286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9287       };
9288     } catch (std::exception& e) {
9289       {
9290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9291       };
9292     } catch (...) {
9293       {
9294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9295       };
9296     }
9297   }
9298   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
9299   return jresult;
9300 }
9301
9302
9303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Add(void * jarg1, void * jarg2) {
9304   void * jresult ;
9305   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9306   Dali::Quaternion *arg2 = 0 ;
9307   Dali::Quaternion result;
9308
9309   arg1 = (Dali::Quaternion *)jarg1;
9310   arg2 = (Dali::Quaternion *)jarg2;
9311   if (!arg2) {
9312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9313     return 0;
9314   }
9315   {
9316     try {
9317       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9318     } catch (std::out_of_range& e) {
9319       {
9320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9321       };
9322     } catch (std::exception& e) {
9323       {
9324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9325       };
9326     } catch (...) {
9327       {
9328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9329       };
9330     }
9331   }
9332   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9333   return jresult;
9334 }
9335
9336
9337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9338   void * jresult ;
9339   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9340   Dali::Quaternion *arg2 = 0 ;
9341   Dali::Quaternion result;
9342
9343   arg1 = (Dali::Quaternion *)jarg1;
9344   arg2 = (Dali::Quaternion *)jarg2;
9345   if (!arg2) {
9346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9347     return 0;
9348   }
9349   {
9350     try {
9351       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9352     } catch (std::out_of_range& e) {
9353       {
9354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9355       };
9356     } catch (std::exception& e) {
9357       {
9358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9359       };
9360     } catch (...) {
9361       {
9362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9363       };
9364     }
9365   }
9366   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9367   return jresult;
9368 }
9369
9370
9371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9372   void * jresult ;
9373   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9374   Dali::Quaternion *arg2 = 0 ;
9375   Dali::Quaternion result;
9376
9377   arg1 = (Dali::Quaternion *)jarg1;
9378   arg2 = (Dali::Quaternion *)jarg2;
9379   if (!arg2) {
9380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9381     return 0;
9382   }
9383   {
9384     try {
9385       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9386     } catch (std::out_of_range& e) {
9387       {
9388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9389       };
9390     } catch (std::exception& e) {
9391       {
9392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9393       };
9394     } catch (...) {
9395       {
9396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9397       };
9398     }
9399   }
9400   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9401   return jresult;
9402 }
9403
9404
9405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9406   void * jresult ;
9407   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9408   Dali::Vector3 *arg2 = 0 ;
9409   Dali::Vector3 result;
9410
9411   arg1 = (Dali::Quaternion *)jarg1;
9412   arg2 = (Dali::Vector3 *)jarg2;
9413   if (!arg2) {
9414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9415     return 0;
9416   }
9417   {
9418     try {
9419       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9420     } catch (std::out_of_range& e) {
9421       {
9422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9423       };
9424     } catch (std::exception& e) {
9425       {
9426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9427       };
9428     } catch (...) {
9429       {
9430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9431       };
9432     }
9433   }
9434   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
9435   return jresult;
9436 }
9437
9438
9439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Divide__SWIG_0(void * jarg1, void * jarg2) {
9440   void * jresult ;
9441   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9442   Dali::Quaternion *arg2 = 0 ;
9443   Dali::Quaternion result;
9444
9445   arg1 = (Dali::Quaternion *)jarg1;
9446   arg2 = (Dali::Quaternion *)jarg2;
9447   if (!arg2) {
9448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9449     return 0;
9450   }
9451   {
9452     try {
9453       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
9454     } catch (std::out_of_range& e) {
9455       {
9456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9457       };
9458     } catch (std::exception& e) {
9459       {
9460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9461       };
9462     } catch (...) {
9463       {
9464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9465       };
9466     }
9467   }
9468   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9469   return jresult;
9470 }
9471
9472
9473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Multiply__SWIG_2(void * jarg1, float jarg2) {
9474   void * jresult ;
9475   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9476   float arg2 ;
9477   Dali::Quaternion result;
9478
9479   arg1 = (Dali::Quaternion *)jarg1;
9480   arg2 = (float)jarg2;
9481   {
9482     try {
9483       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
9484     } catch (std::out_of_range& e) {
9485       {
9486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9487       };
9488     } catch (std::exception& e) {
9489       {
9490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9491       };
9492     } catch (...) {
9493       {
9494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9495       };
9496     }
9497   }
9498   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9499   return jresult;
9500 }
9501
9502
9503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Divide__SWIG_1(void * jarg1, float jarg2) {
9504   void * jresult ;
9505   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9506   float arg2 ;
9507   Dali::Quaternion result;
9508
9509   arg1 = (Dali::Quaternion *)jarg1;
9510   arg2 = (float)jarg2;
9511   {
9512     try {
9513       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
9514     } catch (std::out_of_range& e) {
9515       {
9516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9517       };
9518     } catch (std::exception& e) {
9519       {
9520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9521       };
9522     } catch (...) {
9523       {
9524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9525       };
9526     }
9527   }
9528   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9529   return jresult;
9530 }
9531
9532
9533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Subtract__SWIG_1(void * jarg1) {
9534   void * jresult ;
9535   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9536   Dali::Quaternion result;
9537
9538   arg1 = (Dali::Quaternion *)jarg1;
9539   {
9540     try {
9541       result = ((Dali::Quaternion const *)arg1)->operator -();
9542     } catch (std::out_of_range& e) {
9543       {
9544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9545       };
9546     } catch (std::exception& e) {
9547       {
9548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9549       };
9550     } catch (...) {
9551       {
9552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9553       };
9554     }
9555   }
9556   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9557   return jresult;
9558 }
9559
9560
9561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_AddAssign(void * jarg1, void * jarg2) {
9562   void * jresult ;
9563   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9564   Dali::Quaternion *arg2 = 0 ;
9565   Dali::Quaternion *result = 0 ;
9566
9567   arg1 = (Dali::Quaternion *)jarg1;
9568   arg2 = (Dali::Quaternion *)jarg2;
9569   if (!arg2) {
9570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9571     return 0;
9572   }
9573   {
9574     try {
9575       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
9576     } catch (std::out_of_range& e) {
9577       {
9578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9579       };
9580     } catch (std::exception& e) {
9581       {
9582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9583       };
9584     } catch (...) {
9585       {
9586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9587       };
9588     }
9589   }
9590   jresult = (void *)result;
9591   return jresult;
9592 }
9593
9594
9595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_SubtractAssign(void * jarg1, void * jarg2) {
9596   void * jresult ;
9597   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9598   Dali::Quaternion *arg2 = 0 ;
9599   Dali::Quaternion *result = 0 ;
9600
9601   arg1 = (Dali::Quaternion *)jarg1;
9602   arg2 = (Dali::Quaternion *)jarg2;
9603   if (!arg2) {
9604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9605     return 0;
9606   }
9607   {
9608     try {
9609       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
9610     } catch (std::out_of_range& e) {
9611       {
9612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9613       };
9614     } catch (std::exception& e) {
9615       {
9616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9617       };
9618     } catch (...) {
9619       {
9620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9621       };
9622     }
9623   }
9624   jresult = (void *)result;
9625   return jresult;
9626 }
9627
9628
9629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
9630   void * jresult ;
9631   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9632   Dali::Quaternion *arg2 = 0 ;
9633   Dali::Quaternion *result = 0 ;
9634
9635   arg1 = (Dali::Quaternion *)jarg1;
9636   arg2 = (Dali::Quaternion *)jarg2;
9637   if (!arg2) {
9638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9639     return 0;
9640   }
9641   {
9642     try {
9643       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
9644     } catch (std::out_of_range& e) {
9645       {
9646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9647       };
9648     } catch (std::exception& e) {
9649       {
9650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9651       };
9652     } catch (...) {
9653       {
9654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9655       };
9656     }
9657   }
9658   jresult = (void *)result;
9659   return jresult;
9660 }
9661
9662
9663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
9664   void * jresult ;
9665   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9666   float arg2 ;
9667   Dali::Quaternion *result = 0 ;
9668
9669   arg1 = (Dali::Quaternion *)jarg1;
9670   arg2 = (float)jarg2;
9671   {
9672     try {
9673       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
9674     } catch (std::out_of_range& e) {
9675       {
9676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9677       };
9678     } catch (std::exception& e) {
9679       {
9680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9681       };
9682     } catch (...) {
9683       {
9684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9685       };
9686     }
9687   }
9688   jresult = (void *)result;
9689   return jresult;
9690 }
9691
9692
9693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_DivideAssign(void * jarg1, float jarg2) {
9694   void * jresult ;
9695   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9696   float arg2 ;
9697   Dali::Quaternion *result = 0 ;
9698
9699   arg1 = (Dali::Quaternion *)jarg1;
9700   arg2 = (float)jarg2;
9701   {
9702     try {
9703       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
9704     } catch (std::out_of_range& e) {
9705       {
9706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9707       };
9708     } catch (std::exception& e) {
9709       {
9710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9711       };
9712     } catch (...) {
9713       {
9714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9715       };
9716     }
9717   }
9718   jresult = (void *)result;
9719   return jresult;
9720 }
9721
9722
9723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Quaternion_EqualTo(void * jarg1, void * jarg2) {
9724   unsigned int jresult ;
9725   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9726   Dali::Quaternion *arg2 = 0 ;
9727   bool result;
9728
9729   arg1 = (Dali::Quaternion *)jarg1;
9730   arg2 = (Dali::Quaternion *)jarg2;
9731   if (!arg2) {
9732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9733     return 0;
9734   }
9735   {
9736     try {
9737       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
9738     } catch (std::out_of_range& e) {
9739       {
9740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9741       };
9742     } catch (std::exception& e) {
9743       {
9744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9745       };
9746     } catch (...) {
9747       {
9748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9749       };
9750     }
9751   }
9752   jresult = result;
9753   return jresult;
9754 }
9755
9756
9757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Quaternion_NotEqualTo(void * jarg1, void * jarg2) {
9758   unsigned int jresult ;
9759   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9760   Dali::Quaternion *arg2 = 0 ;
9761   bool result;
9762
9763   arg1 = (Dali::Quaternion *)jarg1;
9764   arg2 = (Dali::Quaternion *)jarg2;
9765   if (!arg2) {
9766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9767     return 0;
9768   }
9769   {
9770     try {
9771       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
9772     } catch (std::out_of_range& e) {
9773       {
9774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9775       };
9776     } catch (std::exception& e) {
9777       {
9778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9779       };
9780     } catch (...) {
9781       {
9782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9783       };
9784     }
9785   }
9786   jresult = result;
9787   return jresult;
9788 }
9789
9790
9791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Quaternion_Length(void * jarg1) {
9792   float jresult ;
9793   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9794   float result;
9795
9796   arg1 = (Dali::Quaternion *)jarg1;
9797   {
9798     try {
9799       result = (float)((Dali::Quaternion const *)arg1)->Length();
9800     } catch (std::out_of_range& e) {
9801       {
9802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9803       };
9804     } catch (std::exception& e) {
9805       {
9806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9807       };
9808     } catch (...) {
9809       {
9810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9811       };
9812     }
9813   }
9814   jresult = result;
9815   return jresult;
9816 }
9817
9818
9819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Quaternion_LengthSquared(void * jarg1) {
9820   float jresult ;
9821   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9822   float result;
9823
9824   arg1 = (Dali::Quaternion *)jarg1;
9825   {
9826     try {
9827       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
9828     } catch (std::out_of_range& e) {
9829       {
9830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9831       };
9832     } catch (std::exception& e) {
9833       {
9834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9835       };
9836     } catch (...) {
9837       {
9838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9839       };
9840     }
9841   }
9842   jresult = result;
9843   return jresult;
9844 }
9845
9846
9847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_Normalize(void * jarg1) {
9848   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9849
9850   arg1 = (Dali::Quaternion *)jarg1;
9851   {
9852     try {
9853       (arg1)->Normalize();
9854     } catch (std::out_of_range& e) {
9855       {
9856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9857       };
9858     } catch (std::exception& e) {
9859       {
9860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9861       };
9862     } catch (...) {
9863       {
9864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9865       };
9866     }
9867   }
9868 }
9869
9870
9871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Normalized(void * jarg1) {
9872   void * jresult ;
9873   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9874   Dali::Quaternion result;
9875
9876   arg1 = (Dali::Quaternion *)jarg1;
9877   {
9878     try {
9879       result = ((Dali::Quaternion const *)arg1)->Normalized();
9880     } catch (std::out_of_range& e) {
9881       {
9882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9883       };
9884     } catch (std::exception& e) {
9885       {
9886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9887       };
9888     } catch (...) {
9889       {
9890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9891       };
9892     }
9893   }
9894   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9895   return jresult;
9896 }
9897
9898
9899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_Conjugate(void * jarg1) {
9900   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9901
9902   arg1 = (Dali::Quaternion *)jarg1;
9903   {
9904     try {
9905       (arg1)->Conjugate();
9906     } catch (std::out_of_range& e) {
9907       {
9908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9909       };
9910     } catch (std::exception& e) {
9911       {
9912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9913       };
9914     } catch (...) {
9915       {
9916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9917       };
9918     }
9919   }
9920 }
9921
9922
9923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_Invert(void * jarg1) {
9924   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9925
9926   arg1 = (Dali::Quaternion *)jarg1;
9927   {
9928     try {
9929       (arg1)->Invert();
9930     } catch (std::out_of_range& e) {
9931       {
9932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9933       };
9934     } catch (std::exception& e) {
9935       {
9936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9937       };
9938     } catch (...) {
9939       {
9940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9941       };
9942     }
9943   }
9944 }
9945
9946
9947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Log(void * jarg1) {
9948   void * jresult ;
9949   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9950   Dali::Quaternion result;
9951
9952   arg1 = (Dali::Quaternion *)jarg1;
9953   {
9954     try {
9955       result = ((Dali::Quaternion const *)arg1)->Log();
9956     } catch (std::out_of_range& e) {
9957       {
9958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9959       };
9960     } catch (std::exception& e) {
9961       {
9962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9963       };
9964     } catch (...) {
9965       {
9966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9967       };
9968     }
9969   }
9970   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9971   return jresult;
9972 }
9973
9974
9975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Exp(void * jarg1) {
9976   void * jresult ;
9977   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9978   Dali::Quaternion result;
9979
9980   arg1 = (Dali::Quaternion *)jarg1;
9981   {
9982     try {
9983       result = ((Dali::Quaternion const *)arg1)->Exp();
9984     } catch (std::out_of_range& e) {
9985       {
9986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9987       };
9988     } catch (std::exception& e) {
9989       {
9990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9991       };
9992     } catch (...) {
9993       {
9994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9995       };
9996     }
9997   }
9998   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9999   return jresult;
10000 }
10001
10002
10003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Quaternion_Dot(void * jarg1, void * jarg2) {
10004   float jresult ;
10005   Dali::Quaternion *arg1 = 0 ;
10006   Dali::Quaternion *arg2 = 0 ;
10007   float result;
10008
10009   arg1 = (Dali::Quaternion *)jarg1;
10010   if (!arg1) {
10011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10012     return 0;
10013   }
10014   arg2 = (Dali::Quaternion *)jarg2;
10015   if (!arg2) {
10016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10017     return 0;
10018   }
10019   {
10020     try {
10021       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10022     } catch (std::out_of_range& e) {
10023       {
10024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10025       };
10026     } catch (std::exception& e) {
10027       {
10028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10029       };
10030     } catch (...) {
10031       {
10032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10033       };
10034     }
10035   }
10036   jresult = result;
10037   return jresult;
10038 }
10039
10040
10041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Lerp(void * jarg1, void * jarg2, float jarg3) {
10042   void * jresult ;
10043   Dali::Quaternion *arg1 = 0 ;
10044   Dali::Quaternion *arg2 = 0 ;
10045   float arg3 ;
10046   Dali::Quaternion result;
10047
10048   arg1 = (Dali::Quaternion *)jarg1;
10049   if (!arg1) {
10050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10051     return 0;
10052   }
10053   arg2 = (Dali::Quaternion *)jarg2;
10054   if (!arg2) {
10055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10056     return 0;
10057   }
10058   arg3 = (float)jarg3;
10059   {
10060     try {
10061       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10062     } catch (std::out_of_range& e) {
10063       {
10064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10065       };
10066     } catch (std::exception& e) {
10067       {
10068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10069       };
10070     } catch (...) {
10071       {
10072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10073       };
10074     }
10075   }
10076   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10077   return jresult;
10078 }
10079
10080
10081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Slerp(void * jarg1, void * jarg2, float jarg3) {
10082   void * jresult ;
10083   Dali::Quaternion *arg1 = 0 ;
10084   Dali::Quaternion *arg2 = 0 ;
10085   float arg3 ;
10086   Dali::Quaternion result;
10087
10088   arg1 = (Dali::Quaternion *)jarg1;
10089   if (!arg1) {
10090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10091     return 0;
10092   }
10093   arg2 = (Dali::Quaternion *)jarg2;
10094   if (!arg2) {
10095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10096     return 0;
10097   }
10098   arg3 = (float)jarg3;
10099   {
10100     try {
10101       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10102     } catch (std::out_of_range& e) {
10103       {
10104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10105       };
10106     } catch (std::exception& e) {
10107       {
10108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10109       };
10110     } catch (...) {
10111       {
10112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10113       };
10114     }
10115   }
10116   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10117   return jresult;
10118 }
10119
10120
10121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10122   void * jresult ;
10123   Dali::Quaternion *arg1 = 0 ;
10124   Dali::Quaternion *arg2 = 0 ;
10125   float arg3 ;
10126   Dali::Quaternion result;
10127
10128   arg1 = (Dali::Quaternion *)jarg1;
10129   if (!arg1) {
10130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10131     return 0;
10132   }
10133   arg2 = (Dali::Quaternion *)jarg2;
10134   if (!arg2) {
10135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10136     return 0;
10137   }
10138   arg3 = (float)jarg3;
10139   {
10140     try {
10141       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10142     } catch (std::out_of_range& e) {
10143       {
10144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10145       };
10146     } catch (std::exception& e) {
10147       {
10148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10149       };
10150     } catch (...) {
10151       {
10152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10153       };
10154     }
10155   }
10156   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10157   return jresult;
10158 }
10159
10160
10161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10162   void * jresult ;
10163   Dali::Quaternion *arg1 = 0 ;
10164   Dali::Quaternion *arg2 = 0 ;
10165   Dali::Quaternion *arg3 = 0 ;
10166   Dali::Quaternion *arg4 = 0 ;
10167   float arg5 ;
10168   Dali::Quaternion result;
10169
10170   arg1 = (Dali::Quaternion *)jarg1;
10171   if (!arg1) {
10172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10173     return 0;
10174   }
10175   arg2 = (Dali::Quaternion *)jarg2;
10176   if (!arg2) {
10177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10178     return 0;
10179   }
10180   arg3 = (Dali::Quaternion *)jarg3;
10181   if (!arg3) {
10182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10183     return 0;
10184   }
10185   arg4 = (Dali::Quaternion *)jarg4;
10186   if (!arg4) {
10187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10188     return 0;
10189   }
10190   arg5 = (float)jarg5;
10191   {
10192     try {
10193       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10194     } catch (std::out_of_range& e) {
10195       {
10196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10197       };
10198     } catch (std::exception& e) {
10199       {
10200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10201       };
10202     } catch (...) {
10203       {
10204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10205       };
10206     }
10207   }
10208   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10209   return jresult;
10210 }
10211
10212
10213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Quaternion_AngleBetween(void * jarg1, void * jarg2) {
10214   float jresult ;
10215   Dali::Quaternion *arg1 = 0 ;
10216   Dali::Quaternion *arg2 = 0 ;
10217   float result;
10218
10219   arg1 = (Dali::Quaternion *)jarg1;
10220   if (!arg1) {
10221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10222     return 0;
10223   }
10224   arg2 = (Dali::Quaternion *)jarg2;
10225   if (!arg2) {
10226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10227     return 0;
10228   }
10229   {
10230     try {
10231       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10232     } catch (std::out_of_range& e) {
10233       {
10234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (std::exception& e) {
10237       {
10238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10239       };
10240     } catch (...) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10243       };
10244     }
10245   }
10246   jresult = result;
10247   return jresult;
10248 }
10249
10250
10251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Rotate__SWIG_0(void * jarg1, void * jarg2) {
10252   void * jresult ;
10253   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10254   Dali::Vector4 *arg2 = 0 ;
10255   Dali::Vector4 result;
10256
10257   arg1 = (Dali::Quaternion *)jarg1;
10258   arg2 = (Dali::Vector4 *)jarg2;
10259   if (!arg2) {
10260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
10261     return 0;
10262   }
10263   {
10264     try {
10265       result = ((Dali::Quaternion const *)arg1)->Rotate((Dali::Vector4 const &)*arg2);
10266     } catch (std::out_of_range& e) {
10267       {
10268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10269       };
10270     } catch (std::exception& e) {
10271       {
10272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10273       };
10274     } catch (...) {
10275       {
10276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10277       };
10278     }
10279   }
10280   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
10281   return jresult;
10282 }
10283
10284
10285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Rotate__SWIG_1(void * jarg1, void * jarg2) {
10286   void * jresult ;
10287   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10288   Dali::Vector3 *arg2 = 0 ;
10289   Dali::Vector3 result;
10290
10291   arg1 = (Dali::Quaternion *)jarg1;
10292   arg2 = (Dali::Vector3 *)jarg2;
10293   if (!arg2) {
10294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10295     return 0;
10296   }
10297   {
10298     try {
10299       result = ((Dali::Quaternion const *)arg1)->Rotate((Dali::Vector3 const &)*arg2);
10300     } catch (std::out_of_range& e) {
10301       {
10302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10303       };
10304     } catch (std::exception& e) {
10305       {
10306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10307       };
10308     } catch (...) {
10309       {
10310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10311       };
10312     }
10313   }
10314   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10315   return jresult;
10316 }
10317
10318
10319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_mVector_set(void * jarg1, void * jarg2) {
10320   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10321   Dali::Vector4 *arg2 = (Dali::Vector4 *) 0 ;
10322
10323   arg1 = (Dali::Quaternion *)jarg1;
10324   arg2 = (Dali::Vector4 *)jarg2;
10325   if (arg1) (arg1)->mVector = *arg2;
10326 }
10327
10328
10329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_mVector_get(void * jarg1) {
10330   void * jresult ;
10331   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10332   Dali::Vector4 *result = 0 ;
10333
10334   arg1 = (Dali::Quaternion *)jarg1;
10335   result = (Dali::Vector4 *)& ((arg1)->mVector);
10336   jresult = (void *)result;
10337   return jresult;
10338 }
10339
10340
10341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10342   void * jresult ;
10343   Dali::Matrix *result = 0 ;
10344
10345   {
10346     try {
10347       result = (Dali::Matrix *)new Dali::Matrix();
10348     } catch (std::out_of_range& e) {
10349       {
10350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10351       };
10352     } catch (std::exception& e) {
10353       {
10354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10355       };
10356     } catch (...) {
10357       {
10358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10359       };
10360     }
10361   }
10362   jresult = (void *)result;
10363   return jresult;
10364 }
10365
10366
10367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10368   void * jresult ;
10369   bool arg1 ;
10370   Dali::Matrix *result = 0 ;
10371
10372   arg1 = jarg1 ? true : false;
10373   {
10374     try {
10375       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10376     } catch (std::out_of_range& e) {
10377       {
10378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10379       };
10380     } catch (std::exception& e) {
10381       {
10382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10383       };
10384     } catch (...) {
10385       {
10386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10387       };
10388     }
10389   }
10390   jresult = (void *)result;
10391   return jresult;
10392 }
10393
10394
10395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10396   void * jresult ;
10397   float *arg1 = (float *) 0 ;
10398   Dali::Matrix *result = 0 ;
10399
10400   arg1 = jarg1;
10401   {
10402     try {
10403       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10404     } catch (std::out_of_range& e) {
10405       {
10406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10407       };
10408     } catch (std::exception& e) {
10409       {
10410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10411       };
10412     } catch (...) {
10413       {
10414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10415       };
10416     }
10417   }
10418   jresult = (void *)result;
10419
10420
10421   return jresult;
10422 }
10423
10424
10425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10426   void * jresult ;
10427   Dali::Quaternion *arg1 = 0 ;
10428   Dali::Matrix *result = 0 ;
10429
10430   arg1 = (Dali::Quaternion *)jarg1;
10431   if (!arg1) {
10432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10433     return 0;
10434   }
10435   {
10436     try {
10437       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10438     } catch (std::out_of_range& e) {
10439       {
10440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10441       };
10442     } catch (std::exception& e) {
10443       {
10444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10445       };
10446     } catch (...) {
10447       {
10448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10449       };
10450     }
10451   }
10452   jresult = (void *)result;
10453   return jresult;
10454 }
10455
10456
10457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10458   void * jresult ;
10459   Dali::Matrix *arg1 = 0 ;
10460   Dali::Matrix *result = 0 ;
10461
10462   arg1 = (Dali::Matrix *)jarg1;
10463   if (!arg1) {
10464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10465     return 0;
10466   }
10467   {
10468     try {
10469       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10470     } catch (std::out_of_range& e) {
10471       {
10472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10473       };
10474     } catch (std::exception& e) {
10475       {
10476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10477       };
10478     } catch (...) {
10479       {
10480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10481       };
10482     }
10483   }
10484   jresult = (void *)result;
10485   return jresult;
10486 }
10487
10488
10489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10490   void * jresult ;
10491   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10492   Dali::Matrix *arg2 = 0 ;
10493   Dali::Matrix *result = 0 ;
10494
10495   arg1 = (Dali::Matrix *)jarg1;
10496   arg2 = (Dali::Matrix *)jarg2;
10497   if (!arg2) {
10498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10499     return 0;
10500   }
10501   {
10502     try {
10503       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10504     } catch (std::out_of_range& e) {
10505       {
10506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10507       };
10508     } catch (std::exception& e) {
10509       {
10510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10511       };
10512     } catch (...) {
10513       {
10514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10515       };
10516     }
10517   }
10518   jresult = (void *)result;
10519   return jresult;
10520 }
10521
10522
10523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
10524   void * jresult ;
10525   Dali::Matrix *result = 0 ;
10526
10527   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
10528   jresult = (void *)result;
10529   return jresult;
10530 }
10531
10532
10533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
10534   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10535
10536   arg1 = (Dali::Matrix *)jarg1;
10537   {
10538     try {
10539       (arg1)->SetIdentity();
10540     } catch (std::out_of_range& e) {
10541       {
10542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10543       };
10544     } catch (std::exception& e) {
10545       {
10546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10547       };
10548     } catch (...) {
10549       {
10550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10551       };
10552     }
10553   }
10554 }
10555
10556
10557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
10558   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10559   Dali::Vector3 *arg2 = 0 ;
10560
10561   arg1 = (Dali::Matrix *)jarg1;
10562   arg2 = (Dali::Vector3 *)jarg2;
10563   if (!arg2) {
10564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10565     return ;
10566   }
10567   {
10568     try {
10569       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
10570     } catch (std::out_of_range& e) {
10571       {
10572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10573       };
10574     } catch (std::exception& e) {
10575       {
10576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10577       };
10578     } catch (...) {
10579       {
10580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10581       };
10582     }
10583   }
10584 }
10585
10586
10587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
10588   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10589   Dali::Matrix *arg2 = 0 ;
10590
10591   arg1 = (Dali::Matrix *)jarg1;
10592   arg2 = (Dali::Matrix *)jarg2;
10593   if (!arg2) {
10594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
10595     return ;
10596   }
10597   {
10598     try {
10599       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
10600     } catch (std::out_of_range& e) {
10601       {
10602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10603       };
10604     } catch (std::exception& e) {
10605       {
10606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10607       };
10608     } catch (...) {
10609       {
10610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10611       };
10612     }
10613   }
10614 }
10615
10616
10617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
10618   unsigned int jresult ;
10619   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10620   bool result;
10621
10622   arg1 = (Dali::Matrix *)jarg1;
10623   {
10624     try {
10625       result = (bool)(arg1)->Invert();
10626     } catch (std::out_of_range& e) {
10627       {
10628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10629       };
10630     } catch (std::exception& e) {
10631       {
10632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10633       };
10634     } catch (...) {
10635       {
10636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10637       };
10638     }
10639   }
10640   jresult = result;
10641   return jresult;
10642 }
10643
10644
10645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
10646   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10647
10648   arg1 = (Dali::Matrix *)jarg1;
10649   {
10650     try {
10651       (arg1)->Transpose();
10652     } catch (std::out_of_range& e) {
10653       {
10654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10655       };
10656     } catch (std::exception& e) {
10657       {
10658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10659       };
10660     } catch (...) {
10661       {
10662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10663       };
10664     }
10665   }
10666 }
10667
10668
10669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
10670   void * jresult ;
10671   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10672   Dali::Vector3 result;
10673
10674   arg1 = (Dali::Matrix *)jarg1;
10675   {
10676     try {
10677       result = ((Dali::Matrix const *)arg1)->GetXAxis();
10678     } catch (std::out_of_range& e) {
10679       {
10680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10681       };
10682     } catch (std::exception& e) {
10683       {
10684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10685       };
10686     } catch (...) {
10687       {
10688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10689       };
10690     }
10691   }
10692   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10693   return jresult;
10694 }
10695
10696
10697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
10698   void * jresult ;
10699   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10700   Dali::Vector3 result;
10701
10702   arg1 = (Dali::Matrix *)jarg1;
10703   {
10704     try {
10705       result = ((Dali::Matrix const *)arg1)->GetYAxis();
10706     } catch (std::out_of_range& e) {
10707       {
10708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10709       };
10710     } catch (std::exception& e) {
10711       {
10712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10713       };
10714     } catch (...) {
10715       {
10716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10717       };
10718     }
10719   }
10720   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10721   return jresult;
10722 }
10723
10724
10725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
10726   void * jresult ;
10727   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10728   Dali::Vector3 result;
10729
10730   arg1 = (Dali::Matrix *)jarg1;
10731   {
10732     try {
10733       result = ((Dali::Matrix const *)arg1)->GetZAxis();
10734     } catch (std::out_of_range& e) {
10735       {
10736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10737       };
10738     } catch (std::exception& e) {
10739       {
10740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10741       };
10742     } catch (...) {
10743       {
10744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10745       };
10746     }
10747   }
10748   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10749   return jresult;
10750 }
10751
10752
10753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
10754   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10755   Dali::Vector3 *arg2 = 0 ;
10756
10757   arg1 = (Dali::Matrix *)jarg1;
10758   arg2 = (Dali::Vector3 *)jarg2;
10759   if (!arg2) {
10760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10761     return ;
10762   }
10763   {
10764     try {
10765       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
10766     } catch (std::out_of_range& e) {
10767       {
10768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10769       };
10770     } catch (std::exception& e) {
10771       {
10772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10773       };
10774     } catch (...) {
10775       {
10776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10777       };
10778     }
10779   }
10780 }
10781
10782
10783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
10784   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10785   Dali::Vector3 *arg2 = 0 ;
10786
10787   arg1 = (Dali::Matrix *)jarg1;
10788   arg2 = (Dali::Vector3 *)jarg2;
10789   if (!arg2) {
10790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10791     return ;
10792   }
10793   {
10794     try {
10795       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
10796     } catch (std::out_of_range& e) {
10797       {
10798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10799       };
10800     } catch (std::exception& e) {
10801       {
10802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10803       };
10804     } catch (...) {
10805       {
10806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10807       };
10808     }
10809   }
10810 }
10811
10812
10813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
10814   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10815   Dali::Vector3 *arg2 = 0 ;
10816
10817   arg1 = (Dali::Matrix *)jarg1;
10818   arg2 = (Dali::Vector3 *)jarg2;
10819   if (!arg2) {
10820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10821     return ;
10822   }
10823   {
10824     try {
10825       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
10826     } catch (std::out_of_range& e) {
10827       {
10828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10829       };
10830     } catch (std::exception& e) {
10831       {
10832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10833       };
10834     } catch (...) {
10835       {
10836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10837       };
10838     }
10839   }
10840 }
10841
10842
10843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
10844   void * jresult ;
10845   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10846   Dali::Vector4 *result = 0 ;
10847
10848   arg1 = (Dali::Matrix *)jarg1;
10849   {
10850     try {
10851       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
10852     } catch (std::out_of_range& e) {
10853       {
10854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10855       };
10856     } catch (std::exception& e) {
10857       {
10858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10859       };
10860     } catch (...) {
10861       {
10862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10863       };
10864     }
10865   }
10866   jresult = (void *)result;
10867   return jresult;
10868 }
10869
10870
10871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
10872   void * jresult ;
10873   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10874   Dali::Vector3 *result = 0 ;
10875
10876   arg1 = (Dali::Matrix *)jarg1;
10877   {
10878     try {
10879       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
10880     } catch (std::out_of_range& e) {
10881       {
10882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10883       };
10884     } catch (std::exception& e) {
10885       {
10886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10887       };
10888     } catch (...) {
10889       {
10890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10891       };
10892     }
10893   }
10894   jresult = (void *)result;
10895   return jresult;
10896 }
10897
10898
10899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
10900   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10901   Dali::Vector4 *arg2 = 0 ;
10902
10903   arg1 = (Dali::Matrix *)jarg1;
10904   arg2 = (Dali::Vector4 *)jarg2;
10905   if (!arg2) {
10906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
10907     return ;
10908   }
10909   {
10910     try {
10911       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
10912     } catch (std::out_of_range& e) {
10913       {
10914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10915       };
10916     } catch (std::exception& e) {
10917       {
10918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10919       };
10920     } catch (...) {
10921       {
10922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10923       };
10924     }
10925   }
10926 }
10927
10928
10929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
10930   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10931   Dali::Vector3 *arg2 = 0 ;
10932
10933   arg1 = (Dali::Matrix *)jarg1;
10934   arg2 = (Dali::Vector3 *)jarg2;
10935   if (!arg2) {
10936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10937     return ;
10938   }
10939   {
10940     try {
10941       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
10942     } catch (std::out_of_range& e) {
10943       {
10944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10945       };
10946     } catch (std::exception& e) {
10947       {
10948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10949       };
10950     } catch (...) {
10951       {
10952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10953       };
10954     }
10955   }
10956 }
10957
10958
10959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
10960   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10961
10962   arg1 = (Dali::Matrix *)jarg1;
10963   {
10964     try {
10965       (arg1)->OrthoNormalize();
10966     } catch (std::out_of_range& e) {
10967       {
10968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10969       };
10970     } catch (std::exception& e) {
10971       {
10972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10973       };
10974     } catch (...) {
10975       {
10976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10977       };
10978     }
10979   }
10980 }
10981
10982
10983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
10984   void * jresult ;
10985   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10986   float *result = 0 ;
10987
10988   arg1 = (Dali::Matrix *)jarg1;
10989   {
10990     try {
10991       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
10992     } catch (std::out_of_range& e) {
10993       {
10994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10995       };
10996     } catch (std::exception& e) {
10997       {
10998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10999       };
11000     } catch (...) {
11001       {
11002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11003       };
11004     }
11005   }
11006   jresult = (void *)result;
11007   return jresult;
11008 }
11009
11010
11011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11012   Dali::Matrix *arg1 = 0 ;
11013   Dali::Matrix *arg2 = 0 ;
11014   Dali::Matrix *arg3 = 0 ;
11015
11016   arg1 = (Dali::Matrix *)jarg1;
11017   if (!arg1) {
11018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11019     return ;
11020   }
11021   arg2 = (Dali::Matrix *)jarg2;
11022   if (!arg2) {
11023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11024     return ;
11025   }
11026   arg3 = (Dali::Matrix *)jarg3;
11027   if (!arg3) {
11028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11029     return ;
11030   }
11031   {
11032     try {
11033       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11034     } catch (std::out_of_range& e) {
11035       {
11036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11037       };
11038     } catch (std::exception& e) {
11039       {
11040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11041       };
11042     } catch (...) {
11043       {
11044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11045       };
11046     }
11047   }
11048 }
11049
11050
11051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11052   Dali::Matrix *arg1 = 0 ;
11053   Dali::Matrix *arg2 = 0 ;
11054   Dali::Quaternion *arg3 = 0 ;
11055
11056   arg1 = (Dali::Matrix *)jarg1;
11057   if (!arg1) {
11058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11059     return ;
11060   }
11061   arg2 = (Dali::Matrix *)jarg2;
11062   if (!arg2) {
11063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11064     return ;
11065   }
11066   arg3 = (Dali::Quaternion *)jarg3;
11067   if (!arg3) {
11068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11069     return ;
11070   }
11071   {
11072     try {
11073       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11074     } catch (std::out_of_range& e) {
11075       {
11076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11077       };
11078     } catch (std::exception& e) {
11079       {
11080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11081       };
11082     } catch (...) {
11083       {
11084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11085       };
11086     }
11087   }
11088 }
11089
11090
11091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11092   void * jresult ;
11093   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11094   Dali::Vector4 *arg2 = 0 ;
11095   Dali::Vector4 result;
11096
11097   arg1 = (Dali::Matrix *)jarg1;
11098   arg2 = (Dali::Vector4 *)jarg2;
11099   if (!arg2) {
11100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11101     return 0;
11102   }
11103   {
11104     try {
11105       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11106     } catch (std::out_of_range& e) {
11107       {
11108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11109       };
11110     } catch (std::exception& e) {
11111       {
11112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11113       };
11114     } catch (...) {
11115       {
11116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11117       };
11118     }
11119   }
11120   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11121   return jresult;
11122 }
11123
11124
11125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11126   unsigned int jresult ;
11127   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11128   Dali::Matrix *arg2 = 0 ;
11129   bool result;
11130
11131   arg1 = (Dali::Matrix *)jarg1;
11132   arg2 = (Dali::Matrix *)jarg2;
11133   if (!arg2) {
11134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11135     return 0;
11136   }
11137   {
11138     try {
11139       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11140     } catch (std::out_of_range& e) {
11141       {
11142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11143       };
11144     } catch (std::exception& e) {
11145       {
11146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11147       };
11148     } catch (...) {
11149       {
11150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11151       };
11152     }
11153   }
11154   jresult = result;
11155   return jresult;
11156 }
11157
11158
11159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11160   unsigned int jresult ;
11161   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11162   Dali::Matrix *arg2 = 0 ;
11163   bool result;
11164
11165   arg1 = (Dali::Matrix *)jarg1;
11166   arg2 = (Dali::Matrix *)jarg2;
11167   if (!arg2) {
11168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11169     return 0;
11170   }
11171   {
11172     try {
11173       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11174     } catch (std::out_of_range& e) {
11175       {
11176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (std::exception& e) {
11179       {
11180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11181       };
11182     } catch (...) {
11183       {
11184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11185       };
11186     }
11187   }
11188   jresult = result;
11189   return jresult;
11190 }
11191
11192
11193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11194   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11195   Dali::Vector3 *arg2 = 0 ;
11196   Dali::Quaternion *arg3 = 0 ;
11197   Dali::Vector3 *arg4 = 0 ;
11198
11199   arg1 = (Dali::Matrix *)jarg1;
11200   arg2 = (Dali::Vector3 *)jarg2;
11201   if (!arg2) {
11202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11203     return ;
11204   }
11205   arg3 = (Dali::Quaternion *)jarg3;
11206   if (!arg3) {
11207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11208     return ;
11209   }
11210   arg4 = (Dali::Vector3 *)jarg4;
11211   if (!arg4) {
11212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11213     return ;
11214   }
11215   {
11216     try {
11217       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11218     } catch (std::out_of_range& e) {
11219       {
11220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11221       };
11222     } catch (std::exception& e) {
11223       {
11224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11225       };
11226     } catch (...) {
11227       {
11228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11229       };
11230     }
11231   }
11232 }
11233
11234
11235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11236   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11237   Dali::Vector3 *arg2 = 0 ;
11238   Dali::Quaternion *arg3 = 0 ;
11239   Dali::Vector3 *arg4 = 0 ;
11240
11241   arg1 = (Dali::Matrix *)jarg1;
11242   arg2 = (Dali::Vector3 *)jarg2;
11243   if (!arg2) {
11244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11245     return ;
11246   }
11247   arg3 = (Dali::Quaternion *)jarg3;
11248   if (!arg3) {
11249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11250     return ;
11251   }
11252   arg4 = (Dali::Vector3 *)jarg4;
11253   if (!arg4) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11255     return ;
11256   }
11257   {
11258     try {
11259       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11267       };
11268     } catch (...) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11271       };
11272     }
11273   }
11274 }
11275
11276
11277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11278   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11279   Dali::Vector3 *arg2 = 0 ;
11280   Dali::Vector3 *arg3 = 0 ;
11281   Dali::Vector3 *arg4 = 0 ;
11282   Dali::Vector3 *arg5 = 0 ;
11283
11284   arg1 = (Dali::Matrix *)jarg1;
11285   arg2 = (Dali::Vector3 *)jarg2;
11286   if (!arg2) {
11287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11288     return ;
11289   }
11290   arg3 = (Dali::Vector3 *)jarg3;
11291   if (!arg3) {
11292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11293     return ;
11294   }
11295   arg4 = (Dali::Vector3 *)jarg4;
11296   if (!arg4) {
11297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11298     return ;
11299   }
11300   arg5 = (Dali::Vector3 *)jarg5;
11301   if (!arg5) {
11302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11303     return ;
11304   }
11305   {
11306     try {
11307       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11308     } catch (std::out_of_range& e) {
11309       {
11310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11311       };
11312     } catch (std::exception& e) {
11313       {
11314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11315       };
11316     } catch (...) {
11317       {
11318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11319       };
11320     }
11321   }
11322 }
11323
11324
11325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11326   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11327   Dali::Vector3 *arg2 = 0 ;
11328   Dali::Quaternion *arg3 = 0 ;
11329   Dali::Vector3 *arg4 = 0 ;
11330
11331   arg1 = (Dali::Matrix *)jarg1;
11332   arg2 = (Dali::Vector3 *)jarg2;
11333   if (!arg2) {
11334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11335     return ;
11336   }
11337   arg3 = (Dali::Quaternion *)jarg3;
11338   if (!arg3) {
11339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11340     return ;
11341   }
11342   arg4 = (Dali::Vector3 *)jarg4;
11343   if (!arg4) {
11344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11345     return ;
11346   }
11347   {
11348     try {
11349       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11350     } catch (std::out_of_range& e) {
11351       {
11352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11353       };
11354     } catch (std::exception& e) {
11355       {
11356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11357       };
11358     } catch (...) {
11359       {
11360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11361       };
11362     }
11363   }
11364 }
11365
11366
11367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11368   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11369
11370   arg1 = (Dali::Matrix *)jarg1;
11371   {
11372     try {
11373       delete arg1;
11374     } catch (std::out_of_range& e) {
11375       {
11376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11377       };
11378     } catch (std::exception& e) {
11379       {
11380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11381       };
11382     } catch (...) {
11383       {
11384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11385       };
11386     }
11387   }
11388 }
11389
11390
11391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11392   void * jresult ;
11393   Dali::Matrix3 *result = 0 ;
11394
11395   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11396   jresult = (void *)result;
11397   return jresult;
11398 }
11399
11400
11401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11402   void * jresult ;
11403   Dali::Matrix3 *result = 0 ;
11404
11405   {
11406     try {
11407       result = (Dali::Matrix3 *)new Dali::Matrix3();
11408     } catch (std::out_of_range& e) {
11409       {
11410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11411       };
11412     } catch (std::exception& e) {
11413       {
11414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11415       };
11416     } catch (...) {
11417       {
11418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11419       };
11420     }
11421   }
11422   jresult = (void *)result;
11423   return jresult;
11424 }
11425
11426
11427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11428   void * jresult ;
11429   Dali::Matrix3 *arg1 = 0 ;
11430   Dali::Matrix3 *result = 0 ;
11431
11432   arg1 = (Dali::Matrix3 *)jarg1;
11433   if (!arg1) {
11434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11435     return 0;
11436   }
11437   {
11438     try {
11439       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11440     } catch (std::out_of_range& e) {
11441       {
11442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11443       };
11444     } catch (std::exception& e) {
11445       {
11446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11447       };
11448     } catch (...) {
11449       {
11450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11451       };
11452     }
11453   }
11454   jresult = (void *)result;
11455   return jresult;
11456 }
11457
11458
11459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11460   void * jresult ;
11461   Dali::Matrix *arg1 = 0 ;
11462   Dali::Matrix3 *result = 0 ;
11463
11464   arg1 = (Dali::Matrix *)jarg1;
11465   if (!arg1) {
11466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11467     return 0;
11468   }
11469   {
11470     try {
11471       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11472     } catch (std::out_of_range& e) {
11473       {
11474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11475       };
11476     } catch (std::exception& e) {
11477       {
11478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11479       };
11480     } catch (...) {
11481       {
11482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11483       };
11484     }
11485   }
11486   jresult = (void *)result;
11487   return jresult;
11488 }
11489
11490
11491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
11492   void * jresult ;
11493   float arg1 ;
11494   float arg2 ;
11495   float arg3 ;
11496   float arg4 ;
11497   float arg5 ;
11498   float arg6 ;
11499   float arg7 ;
11500   float arg8 ;
11501   float arg9 ;
11502   Dali::Matrix3 *result = 0 ;
11503
11504   arg1 = (float)jarg1;
11505   arg2 = (float)jarg2;
11506   arg3 = (float)jarg3;
11507   arg4 = (float)jarg4;
11508   arg5 = (float)jarg5;
11509   arg6 = (float)jarg6;
11510   arg7 = (float)jarg7;
11511   arg8 = (float)jarg8;
11512   arg9 = (float)jarg9;
11513   {
11514     try {
11515       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11516     } catch (std::out_of_range& e) {
11517       {
11518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11519       };
11520     } catch (std::exception& e) {
11521       {
11522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11523       };
11524     } catch (...) {
11525       {
11526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11527       };
11528     }
11529   }
11530   jresult = (void *)result;
11531   return jresult;
11532 }
11533
11534
11535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
11536   void * jresult ;
11537   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11538   Dali::Matrix3 *arg2 = 0 ;
11539   Dali::Matrix3 *result = 0 ;
11540
11541   arg1 = (Dali::Matrix3 *)jarg1;
11542   arg2 = (Dali::Matrix3 *)jarg2;
11543   if (!arg2) {
11544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11545     return 0;
11546   }
11547   {
11548     try {
11549       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
11550     } catch (std::out_of_range& e) {
11551       {
11552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11553       };
11554     } catch (std::exception& e) {
11555       {
11556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11557       };
11558     } catch (...) {
11559       {
11560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11561       };
11562     }
11563   }
11564   jresult = (void *)result;
11565   return jresult;
11566 }
11567
11568
11569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
11570   void * jresult ;
11571   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11572   Dali::Matrix *arg2 = 0 ;
11573   Dali::Matrix3 *result = 0 ;
11574
11575   arg1 = (Dali::Matrix3 *)jarg1;
11576   arg2 = (Dali::Matrix *)jarg2;
11577   if (!arg2) {
11578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11579     return 0;
11580   }
11581   {
11582     try {
11583       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11584     } catch (std::out_of_range& e) {
11585       {
11586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11587       };
11588     } catch (std::exception& e) {
11589       {
11590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11591       };
11592     } catch (...) {
11593       {
11594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11595       };
11596     }
11597   }
11598   jresult = (void *)result;
11599   return jresult;
11600 }
11601
11602
11603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
11604   unsigned int jresult ;
11605   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11606   Dali::Matrix3 *arg2 = 0 ;
11607   bool result;
11608
11609   arg1 = (Dali::Matrix3 *)jarg1;
11610   arg2 = (Dali::Matrix3 *)jarg2;
11611   if (!arg2) {
11612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11613     return 0;
11614   }
11615   {
11616     try {
11617       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
11618     } catch (std::out_of_range& e) {
11619       {
11620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11621       };
11622     } catch (std::exception& e) {
11623       {
11624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11625       };
11626     } catch (...) {
11627       {
11628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11629       };
11630     }
11631   }
11632   jresult = result;
11633   return jresult;
11634 }
11635
11636
11637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
11638   unsigned int jresult ;
11639   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11640   Dali::Matrix3 *arg2 = 0 ;
11641   bool result;
11642
11643   arg1 = (Dali::Matrix3 *)jarg1;
11644   arg2 = (Dali::Matrix3 *)jarg2;
11645   if (!arg2) {
11646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11647     return 0;
11648   }
11649   {
11650     try {
11651       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
11652     } catch (std::out_of_range& e) {
11653       {
11654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11655       };
11656     } catch (std::exception& e) {
11657       {
11658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11659       };
11660     } catch (...) {
11661       {
11662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11663       };
11664     }
11665   }
11666   jresult = result;
11667   return jresult;
11668 }
11669
11670
11671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
11672   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11673
11674   arg1 = (Dali::Matrix3 *)jarg1;
11675   {
11676     try {
11677       delete arg1;
11678     } catch (std::out_of_range& e) {
11679       {
11680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11681       };
11682     } catch (std::exception& e) {
11683       {
11684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11685       };
11686     } catch (...) {
11687       {
11688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11689       };
11690     }
11691   }
11692 }
11693
11694
11695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
11696   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11697
11698   arg1 = (Dali::Matrix3 *)jarg1;
11699   {
11700     try {
11701       (arg1)->SetIdentity();
11702     } catch (std::out_of_range& e) {
11703       {
11704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11705       };
11706     } catch (std::exception& e) {
11707       {
11708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11709       };
11710     } catch (...) {
11711       {
11712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11713       };
11714     }
11715   }
11716 }
11717
11718
11719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
11720   void * jresult ;
11721   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11722   float *result = 0 ;
11723
11724   arg1 = (Dali::Matrix3 *)jarg1;
11725   {
11726     try {
11727       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
11728     } catch (std::out_of_range& e) {
11729       {
11730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11731       };
11732     } catch (std::exception& e) {
11733       {
11734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11735       };
11736     } catch (...) {
11737       {
11738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11739       };
11740     }
11741   }
11742   jresult = (void *)result;
11743   return jresult;
11744 }
11745
11746
11747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
11748   unsigned int jresult ;
11749   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11750   bool result;
11751
11752   arg1 = (Dali::Matrix3 *)jarg1;
11753   {
11754     try {
11755       result = (bool)(arg1)->Invert();
11756     } catch (std::out_of_range& e) {
11757       {
11758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11759       };
11760     } catch (std::exception& e) {
11761       {
11762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11763       };
11764     } catch (...) {
11765       {
11766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11767       };
11768     }
11769   }
11770   jresult = result;
11771   return jresult;
11772 }
11773
11774
11775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
11776   unsigned int jresult ;
11777   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11778   bool result;
11779
11780   arg1 = (Dali::Matrix3 *)jarg1;
11781   {
11782     try {
11783       result = (bool)(arg1)->Transpose();
11784     } catch (std::out_of_range& e) {
11785       {
11786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11787       };
11788     } catch (std::exception& e) {
11789       {
11790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11791       };
11792     } catch (...) {
11793       {
11794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11795       };
11796     }
11797   }
11798   jresult = result;
11799   return jresult;
11800 }
11801
11802
11803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
11804   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11805   float arg2 ;
11806
11807   arg1 = (Dali::Matrix3 *)jarg1;
11808   arg2 = (float)jarg2;
11809   {
11810     try {
11811       (arg1)->Scale(arg2);
11812     } catch (std::out_of_range& e) {
11813       {
11814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11815       };
11816     } catch (std::exception& e) {
11817       {
11818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11819       };
11820     } catch (...) {
11821       {
11822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11823       };
11824     }
11825   }
11826 }
11827
11828
11829 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
11830   float jresult ;
11831   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11832   float result;
11833
11834   arg1 = (Dali::Matrix3 *)jarg1;
11835   {
11836     try {
11837       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
11838     } catch (std::out_of_range& e) {
11839       {
11840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11841       };
11842     } catch (std::exception& e) {
11843       {
11844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11845       };
11846     } catch (...) {
11847       {
11848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11849       };
11850     }
11851   }
11852   jresult = result;
11853   return jresult;
11854 }
11855
11856
11857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
11858   unsigned int jresult ;
11859   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11860   bool result;
11861
11862   arg1 = (Dali::Matrix3 *)jarg1;
11863   {
11864     try {
11865       result = (bool)(arg1)->ScaledInverseTranspose();
11866     } catch (std::out_of_range& e) {
11867       {
11868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11869       };
11870     } catch (std::exception& e) {
11871       {
11872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11873       };
11874     } catch (...) {
11875       {
11876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11877       };
11878     }
11879   }
11880   jresult = result;
11881   return jresult;
11882 }
11883
11884
11885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
11886   Dali::Matrix3 *arg1 = 0 ;
11887   Dali::Matrix3 *arg2 = 0 ;
11888   Dali::Matrix3 *arg3 = 0 ;
11889
11890   arg1 = (Dali::Matrix3 *)jarg1;
11891   if (!arg1) {
11892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
11893     return ;
11894   }
11895   arg2 = (Dali::Matrix3 *)jarg2;
11896   if (!arg2) {
11897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11898     return ;
11899   }
11900   arg3 = (Dali::Matrix3 *)jarg3;
11901   if (!arg3) {
11902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11903     return ;
11904   }
11905   {
11906     try {
11907       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
11908     } catch (std::out_of_range& e) {
11909       {
11910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11911       };
11912     } catch (std::exception& e) {
11913       {
11914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11915       };
11916     } catch (...) {
11917       {
11918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11919       };
11920     }
11921   }
11922 }
11923
11924
11925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
11926   float jresult ;
11927   float arg1 ;
11928   float arg2 ;
11929   float result;
11930
11931   arg1 = (float)jarg1;
11932   arg2 = (float)jarg2;
11933   {
11934     try {
11935       result = (float)Dali::Random::Range(arg1,arg2);
11936     } catch (std::out_of_range& e) {
11937       {
11938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11939       };
11940     } catch (std::exception& e) {
11941       {
11942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11943       };
11944     } catch (...) {
11945       {
11946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11947       };
11948     }
11949   }
11950   jresult = result;
11951   return jresult;
11952 }
11953
11954
11955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
11956   void * jresult ;
11957   Dali::Vector4 result;
11958
11959   {
11960     try {
11961       result = Dali::Random::Axis();
11962     } catch (std::out_of_range& e) {
11963       {
11964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11965       };
11966     } catch (std::exception& e) {
11967       {
11968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (...) {
11971       {
11972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11973       };
11974     }
11975   }
11976   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11977   return jresult;
11978 }
11979
11980
11981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
11982   void * jresult ;
11983   Dali::AngleAxis *result = 0 ;
11984
11985   {
11986     try {
11987       result = (Dali::AngleAxis *)new Dali::AngleAxis();
11988     } catch (std::out_of_range& e) {
11989       {
11990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11991       };
11992     } catch (std::exception& e) {
11993       {
11994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11995       };
11996     } catch (...) {
11997       {
11998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11999       };
12000     }
12001   }
12002   jresult = (void *)result;
12003   return jresult;
12004 }
12005
12006
12007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12008   void * jresult ;
12009   Dali::Radian arg1 ;
12010   Dali::Vector3 *arg2 = 0 ;
12011   Dali::Radian *argp1 ;
12012   Dali::AngleAxis *result = 0 ;
12013
12014   argp1 = (Dali::Radian *)jarg1;
12015   if (!argp1) {
12016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12017     return 0;
12018   }
12019   arg1 = *argp1;
12020   arg2 = (Dali::Vector3 *)jarg2;
12021   if (!arg2) {
12022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12023     return 0;
12024   }
12025   {
12026     try {
12027       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12028     } catch (std::out_of_range& e) {
12029       {
12030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12031       };
12032     } catch (std::exception& e) {
12033       {
12034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12035       };
12036     } catch (...) {
12037       {
12038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12039       };
12040     }
12041   }
12042   jresult = (void *)result;
12043   return jresult;
12044 }
12045
12046
12047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12048   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12049   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12050
12051   arg1 = (Dali::AngleAxis *)jarg1;
12052   arg2 = (Dali::Radian *)jarg2;
12053   if (arg1) (arg1)->angle = *arg2;
12054 }
12055
12056
12057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12058   void * jresult ;
12059   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12060   Dali::Radian *result = 0 ;
12061
12062   arg1 = (Dali::AngleAxis *)jarg1;
12063   result = (Dali::Radian *)& ((arg1)->angle);
12064   jresult = (void *)result;
12065   return jresult;
12066 }
12067
12068
12069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12070   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12071   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12072
12073   arg1 = (Dali::AngleAxis *)jarg1;
12074   arg2 = (Dali::Vector3 *)jarg2;
12075   if (arg1) (arg1)->axis = *arg2;
12076 }
12077
12078
12079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12080   void * jresult ;
12081   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12082   Dali::Vector3 *result = 0 ;
12083
12084   arg1 = (Dali::AngleAxis *)jarg1;
12085   result = (Dali::Vector3 *)& ((arg1)->axis);
12086   jresult = (void *)result;
12087   return jresult;
12088 }
12089
12090
12091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12092   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12093
12094   arg1 = (Dali::AngleAxis *)jarg1;
12095   {
12096     try {
12097       delete arg1;
12098     } catch (std::out_of_range& e) {
12099       {
12100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12101       };
12102     } catch (std::exception& e) {
12103       {
12104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12105       };
12106     } catch (...) {
12107       {
12108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12109       };
12110     }
12111   }
12112 }
12113
12114
12115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12116   unsigned int jresult ;
12117   Dali::AngleAxis *arg1 = 0 ;
12118   Dali::AngleAxis *arg2 = 0 ;
12119   bool result;
12120
12121   arg1 = (Dali::AngleAxis *)jarg1;
12122   if (!arg1) {
12123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12124     return 0;
12125   }
12126   arg2 = (Dali::AngleAxis *)jarg2;
12127   if (!arg2) {
12128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12129     return 0;
12130   }
12131   {
12132     try {
12133       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12134     } catch (std::out_of_range& e) {
12135       {
12136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12137       };
12138     } catch (std::exception& e) {
12139       {
12140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12141       };
12142     } catch (...) {
12143       {
12144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12145       };
12146     }
12147   }
12148   jresult = result;
12149   return jresult;
12150 }
12151
12152
12153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12154   int jresult ;
12155   int result;
12156
12157   result = (int)(int)Dali::Property::INVALID_INDEX;
12158   jresult = result;
12159   return jresult;
12160 }
12161
12162
12163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12164   int jresult ;
12165   int result;
12166
12167   result = (int)(int)Dali::Property::INVALID_KEY;
12168   jresult = result;
12169   return jresult;
12170 }
12171
12172
12173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12174   int jresult ;
12175   int result;
12176
12177   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12178   jresult = result;
12179   return jresult;
12180 }
12181
12182
12183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12184   void * jresult ;
12185   Dali::Handle *arg1 = 0 ;
12186   Dali::Property::Index arg2 ;
12187   Dali::Property *result = 0 ;
12188
12189   arg1 = (Dali::Handle *)jarg1;
12190   if (!arg1) {
12191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12192     return 0;
12193   }
12194   arg2 = (Dali::Property::Index)jarg2;
12195   {
12196     try {
12197       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12198     } catch (std::out_of_range& e) {
12199       {
12200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12201       };
12202     } catch (std::exception& e) {
12203       {
12204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12205       };
12206     } catch (...) {
12207       {
12208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12209       };
12210     }
12211   }
12212   jresult = (void *)result;
12213   return jresult;
12214 }
12215
12216
12217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12218   void * jresult ;
12219   Dali::Handle *arg1 = 0 ;
12220   Dali::Property::Index arg2 ;
12221   int arg3 ;
12222   Dali::Property *result = 0 ;
12223
12224   arg1 = (Dali::Handle *)jarg1;
12225   if (!arg1) {
12226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12227     return 0;
12228   }
12229   arg2 = (Dali::Property::Index)jarg2;
12230   arg3 = (int)jarg3;
12231   {
12232     try {
12233       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12234     } catch (std::out_of_range& e) {
12235       {
12236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12237       };
12238     } catch (std::exception& e) {
12239       {
12240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12241       };
12242     } catch (...) {
12243       {
12244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12245       };
12246     }
12247   }
12248   jresult = (void *)result;
12249   return jresult;
12250 }
12251
12252
12253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
12254   void * jresult ;
12255   Dali::Handle *arg1 = 0 ;
12256   std::string *arg2 = 0 ;
12257   Dali::Property *result = 0 ;
12258
12259   arg1 = (Dali::Handle *)jarg1;
12260   if (!arg1) {
12261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12262     return 0;
12263   }
12264   if (!jarg2) {
12265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12266     return 0;
12267   }
12268   std::string arg2_str(jarg2);
12269   arg2 = &arg2_str;
12270   {
12271     try {
12272       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
12273     } catch (std::out_of_range& e) {
12274       {
12275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12276       };
12277     } catch (std::exception& e) {
12278       {
12279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12280       };
12281     } catch (...) {
12282       {
12283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12284       };
12285     }
12286   }
12287   jresult = (void *)result;
12288
12289   //argout typemap for const std::string&
12290
12291   return jresult;
12292 }
12293
12294
12295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
12296   void * jresult ;
12297   Dali::Handle *arg1 = 0 ;
12298   std::string *arg2 = 0 ;
12299   int arg3 ;
12300   Dali::Property *result = 0 ;
12301
12302   arg1 = (Dali::Handle *)jarg1;
12303   if (!arg1) {
12304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12305     return 0;
12306   }
12307   if (!jarg2) {
12308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12309     return 0;
12310   }
12311   std::string arg2_str(jarg2);
12312   arg2 = &arg2_str;
12313   arg3 = (int)jarg3;
12314   {
12315     try {
12316       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
12317     } catch (std::out_of_range& e) {
12318       {
12319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12320       };
12321     } catch (std::exception& e) {
12322       {
12323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12324       };
12325     } catch (...) {
12326       {
12327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12328       };
12329     }
12330   }
12331   jresult = (void *)result;
12332
12333   //argout typemap for const std::string&
12334
12335   return jresult;
12336 }
12337
12338
12339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
12340   Dali::Property *arg1 = (Dali::Property *) 0 ;
12341
12342   arg1 = (Dali::Property *)jarg1;
12343   {
12344     try {
12345       delete arg1;
12346     } catch (std::out_of_range& e) {
12347       {
12348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12349       };
12350     } catch (std::exception& e) {
12351       {
12352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12353       };
12354     } catch (...) {
12355       {
12356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12357       };
12358     }
12359   }
12360 }
12361
12362
12363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
12364   Dali::Property *arg1 = (Dali::Property *) 0 ;
12365   Dali::Handle *arg2 = 0 ;
12366
12367   arg1 = (Dali::Property *)jarg1;
12368   arg2 = (Dali::Handle *)jarg2;
12369   if (!arg2) {
12370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12371     return ;
12372   }
12373   if (arg1) (arg1)->object = *arg2;
12374 }
12375
12376
12377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
12378   void * jresult ;
12379   Dali::Property *arg1 = (Dali::Property *) 0 ;
12380   Dali::Handle *result = 0 ;
12381
12382   arg1 = (Dali::Property *)jarg1;
12383   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
12384   jresult = (void *)result;
12385   return jresult;
12386 }
12387
12388
12389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
12390   Dali::Property *arg1 = (Dali::Property *) 0 ;
12391   Dali::Property::Index arg2 ;
12392
12393   arg1 = (Dali::Property *)jarg1;
12394   arg2 = (Dali::Property::Index)jarg2;
12395   if (arg1) (arg1)->propertyIndex = arg2;
12396 }
12397
12398
12399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
12400   int jresult ;
12401   Dali::Property *arg1 = (Dali::Property *) 0 ;
12402   Dali::Property::Index result;
12403
12404   arg1 = (Dali::Property *)jarg1;
12405   result = (Dali::Property::Index) ((arg1)->propertyIndex);
12406   jresult = result;
12407   return jresult;
12408 }
12409
12410
12411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
12412   Dali::Property *arg1 = (Dali::Property *) 0 ;
12413   int arg2 ;
12414
12415   arg1 = (Dali::Property *)jarg1;
12416   arg2 = (int)jarg2;
12417   if (arg1) (arg1)->componentIndex = arg2;
12418 }
12419
12420
12421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
12422   int jresult ;
12423   Dali::Property *arg1 = (Dali::Property *) 0 ;
12424   int result;
12425
12426   arg1 = (Dali::Property *)jarg1;
12427   result = (int) ((arg1)->componentIndex);
12428   jresult = result;
12429   return jresult;
12430 }
12431
12432
12433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
12434   void * jresult ;
12435   Dali::Property::Array *result = 0 ;
12436
12437   {
12438     try {
12439       result = (Dali::Property::Array *)new Dali::Property::Array();
12440     } catch (std::out_of_range& e) {
12441       {
12442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12443       };
12444     } catch (std::exception& e) {
12445       {
12446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12447       };
12448     } catch (...) {
12449       {
12450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12451       };
12452     }
12453   }
12454   jresult = (void *)result;
12455   return jresult;
12456 }
12457
12458
12459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
12460   void * jresult ;
12461   Dali::Property::Array *arg1 = 0 ;
12462   Dali::Property::Array *result = 0 ;
12463
12464   arg1 = (Dali::Property::Array *)jarg1;
12465   if (!arg1) {
12466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
12467     return 0;
12468   }
12469   {
12470     try {
12471       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
12472     } catch (std::out_of_range& e) {
12473       {
12474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12475       };
12476     } catch (std::exception& e) {
12477       {
12478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12479       };
12480     } catch (...) {
12481       {
12482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12483       };
12484     }
12485   }
12486   jresult = (void *)result;
12487   return jresult;
12488 }
12489
12490
12491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
12492   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12493
12494   arg1 = (Dali::Property::Array *)jarg1;
12495   {
12496     try {
12497       delete arg1;
12498     } catch (std::out_of_range& e) {
12499       {
12500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12501       };
12502     } catch (std::exception& e) {
12503       {
12504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12505       };
12506     } catch (...) {
12507       {
12508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12509       };
12510     }
12511   }
12512 }
12513
12514
12515 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
12516   unsigned long jresult ;
12517   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12518   Dali::Property::Array::SizeType result;
12519
12520   arg1 = (Dali::Property::Array *)jarg1;
12521   {
12522     try {
12523       result = ((Dali::Property::Array const *)arg1)->Size();
12524     } catch (std::out_of_range& e) {
12525       {
12526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12527       };
12528     } catch (std::exception& e) {
12529       {
12530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12531       };
12532     } catch (...) {
12533       {
12534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12535       };
12536     }
12537   }
12538   jresult = (unsigned long)result;
12539   return jresult;
12540 }
12541
12542
12543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
12544   unsigned long jresult ;
12545   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12546   Dali::Property::Array::SizeType result;
12547
12548   arg1 = (Dali::Property::Array *)jarg1;
12549   {
12550     try {
12551       result = ((Dali::Property::Array const *)arg1)->Count();
12552     } catch (std::out_of_range& e) {
12553       {
12554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12555       };
12556     } catch (std::exception& e) {
12557       {
12558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12559       };
12560     } catch (...) {
12561       {
12562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12563       };
12564     }
12565   }
12566   jresult = (unsigned long)result;
12567   return jresult;
12568 }
12569
12570
12571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
12572   unsigned int jresult ;
12573   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12574   bool result;
12575
12576   arg1 = (Dali::Property::Array *)jarg1;
12577   {
12578     try {
12579       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
12580     } catch (std::out_of_range& e) {
12581       {
12582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12583       };
12584     } catch (std::exception& e) {
12585       {
12586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12587       };
12588     } catch (...) {
12589       {
12590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12591       };
12592     }
12593   }
12594   jresult = result;
12595   return jresult;
12596 }
12597
12598
12599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
12600   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12601
12602   arg1 = (Dali::Property::Array *)jarg1;
12603   {
12604     try {
12605       (arg1)->Clear();
12606     } catch (std::out_of_range& e) {
12607       {
12608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12609       };
12610     } catch (std::exception& e) {
12611       {
12612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12613       };
12614     } catch (...) {
12615       {
12616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12617       };
12618     }
12619   }
12620 }
12621
12622
12623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
12624   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12625   Dali::Property::Array::SizeType arg2 ;
12626
12627   arg1 = (Dali::Property::Array *)jarg1;
12628   arg2 = (Dali::Property::Array::SizeType)jarg2;
12629   {
12630     try {
12631       (arg1)->Reserve(arg2);
12632     } catch (std::out_of_range& e) {
12633       {
12634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12635       };
12636     } catch (std::exception& e) {
12637       {
12638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12639       };
12640     } catch (...) {
12641       {
12642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12643       };
12644     }
12645   }
12646 }
12647
12648
12649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
12650   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12651   Dali::Property::Array::SizeType arg2 ;
12652
12653   arg1 = (Dali::Property::Array *)jarg1;
12654   arg2 = (Dali::Property::Array::SizeType)jarg2;
12655   {
12656     try {
12657       (arg1)->Resize(arg2);
12658     } catch (std::out_of_range& e) {
12659       {
12660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12661       };
12662     } catch (std::exception& e) {
12663       {
12664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12665       };
12666     } catch (...) {
12667       {
12668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12669       };
12670     }
12671   }
12672 }
12673
12674
12675 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
12676   unsigned long jresult ;
12677   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12678   Dali::Property::Array::SizeType result;
12679
12680   arg1 = (Dali::Property::Array *)jarg1;
12681   {
12682     try {
12683       result = (arg1)->Capacity();
12684     } catch (std::out_of_range& e) {
12685       {
12686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12687       };
12688     } catch (std::exception& e) {
12689       {
12690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12691       };
12692     } catch (...) {
12693       {
12694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12695       };
12696     }
12697   }
12698   jresult = (unsigned long)result;
12699   return jresult;
12700 }
12701
12702
12703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
12704   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12705   Dali::Property::Value *arg2 = 0 ;
12706
12707   arg1 = (Dali::Property::Array *)jarg1;
12708   arg2 = (Dali::Property::Value *)jarg2;
12709   if (!arg2) {
12710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
12711     return ;
12712   }
12713   {
12714     try {
12715       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
12716     } catch (std::out_of_range& e) {
12717       {
12718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12719       };
12720     } catch (std::exception& e) {
12721       {
12722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12723       };
12724     } catch (...) {
12725       {
12726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12727       };
12728     }
12729   }
12730 }
12731
12732
12733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
12734   void * jresult ;
12735   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12736   Dali::Property::Array::SizeType arg2 ;
12737   Dali::Property::Value *result = 0 ;
12738
12739   arg1 = (Dali::Property::Array *)jarg1;
12740   arg2 = (Dali::Property::Array::SizeType)jarg2;
12741   {
12742     try {
12743       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
12744     } catch (std::out_of_range& e) {
12745       {
12746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12747       };
12748     } catch (std::exception& e) {
12749       {
12750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12751       };
12752     } catch (...) {
12753       {
12754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12755       };
12756     }
12757   }
12758   jresult = (void *)result;
12759   return jresult;
12760 }
12761
12762
12763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
12764   void * jresult ;
12765   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12766   Dali::Property::Array::SizeType arg2 ;
12767   Dali::Property::Value *result = 0 ;
12768
12769   arg1 = (Dali::Property::Array *)jarg1;
12770   arg2 = (Dali::Property::Array::SizeType)jarg2;
12771   {
12772     try {
12773       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
12774     } catch (std::out_of_range& e) {
12775       {
12776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12777       };
12778     } catch (std::exception& e) {
12779       {
12780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (...) {
12783       {
12784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12785       };
12786     }
12787   }
12788   jresult = (void *)result;
12789   return jresult;
12790 }
12791
12792
12793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
12794   void * jresult ;
12795   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
12796   Dali::Property::Array *arg2 = 0 ;
12797   Dali::Property::Array *result = 0 ;
12798
12799   arg1 = (Dali::Property::Array *)jarg1;
12800   arg2 = (Dali::Property::Array *)jarg2;
12801   if (!arg2) {
12802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
12803     return 0;
12804   }
12805   {
12806     try {
12807       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
12808     } catch (std::out_of_range& e) {
12809       {
12810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12811       };
12812     } catch (std::exception& e) {
12813       {
12814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12815       };
12816     } catch (...) {
12817       {
12818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12819       };
12820     }
12821   }
12822   jresult = (void *)result;
12823   return jresult;
12824 }
12825
12826
12827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
12828   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
12829   enum Dali::Property::Key::Type arg2 ;
12830
12831   arg1 = (Dali::Property::Key *)jarg1;
12832   arg2 = (enum Dali::Property::Key::Type)jarg2;
12833   if (arg1) (arg1)->type = arg2;
12834 }
12835
12836
12837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
12838   int jresult ;
12839   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
12840   enum Dali::Property::Key::Type result;
12841
12842   arg1 = (Dali::Property::Key *)jarg1;
12843   result = (enum Dali::Property::Key::Type) ((arg1)->type);
12844   jresult = (int)result;
12845   return jresult;
12846 }
12847
12848
12849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
12850   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
12851   Dali::Property::Index arg2 ;
12852
12853   arg1 = (Dali::Property::Key *)jarg1;
12854   arg2 = (Dali::Property::Index)jarg2;
12855   if (arg1) (arg1)->indexKey = arg2;
12856 }
12857
12858
12859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
12860   int jresult ;
12861   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
12862   Dali::Property::Index result;
12863
12864   arg1 = (Dali::Property::Key *)jarg1;
12865   result = (Dali::Property::Index) ((arg1)->indexKey);
12866   jresult = result;
12867   return jresult;
12868 }
12869
12870
12871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
12872   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
12873   std::string *arg2 = 0 ;
12874
12875   arg1 = (Dali::Property::Key *)jarg1;
12876   if (!jarg2) {
12877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12878     return ;
12879   }
12880   std::string arg2_str(jarg2);
12881   arg2 = &arg2_str;
12882   if (arg1) (arg1)->stringKey = *arg2;
12883
12884   //argout typemap for const std::string&
12885
12886 }
12887
12888
12889 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
12890   char * jresult ;
12891   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
12892   std::string *result = 0 ;
12893
12894   arg1 = (Dali::Property::Key *)jarg1;
12895   result = (std::string *) & ((arg1)->stringKey);
12896   jresult = SWIG_csharp_string_callback(result->c_str());
12897   return jresult;
12898 }
12899
12900
12901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
12902   void * jresult ;
12903   std::string *arg1 = 0 ;
12904   Dali::Property::Key *result = 0 ;
12905
12906   if (!jarg1) {
12907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12908     return 0;
12909   }
12910   std::string arg1_str(jarg1);
12911   arg1 = &arg1_str;
12912   {
12913     try {
12914       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
12915     } catch (std::out_of_range& e) {
12916       {
12917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12918       };
12919     } catch (std::exception& e) {
12920       {
12921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12922       };
12923     } catch (...) {
12924       {
12925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12926       };
12927     }
12928   }
12929   jresult = (void *)result;
12930
12931   //argout typemap for const std::string&
12932
12933   return jresult;
12934 }
12935
12936
12937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
12938   void * jresult ;
12939   Dali::Property::Index arg1 ;
12940   Dali::Property::Key *result = 0 ;
12941
12942   arg1 = (Dali::Property::Index)jarg1;
12943   {
12944     try {
12945       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
12946     } catch (std::out_of_range& e) {
12947       {
12948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12949       };
12950     } catch (std::exception& e) {
12951       {
12952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12953       };
12954     } catch (...) {
12955       {
12956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12957       };
12958     }
12959   }
12960   jresult = (void *)result;
12961   return jresult;
12962 }
12963
12964
12965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
12966   unsigned int jresult ;
12967   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
12968   std::string *arg2 = 0 ;
12969   bool result;
12970
12971   arg1 = (Dali::Property::Key *)jarg1;
12972   if (!jarg2) {
12973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12974     return 0;
12975   }
12976   std::string arg2_str(jarg2);
12977   arg2 = &arg2_str;
12978   {
12979     try {
12980       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
12981     } catch (std::out_of_range& e) {
12982       {
12983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12984       };
12985     } catch (std::exception& e) {
12986       {
12987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12988       };
12989     } catch (...) {
12990       {
12991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12992       };
12993     }
12994   }
12995   jresult = result;
12996
12997   //argout typemap for const std::string&
12998
12999   return jresult;
13000 }
13001
13002
13003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13004   unsigned int jresult ;
13005   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13006   Dali::Property::Index arg2 ;
13007   bool result;
13008
13009   arg1 = (Dali::Property::Key *)jarg1;
13010   arg2 = (Dali::Property::Index)jarg2;
13011   {
13012     try {
13013       result = (bool)(arg1)->operator ==(arg2);
13014     } catch (std::out_of_range& e) {
13015       {
13016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13017       };
13018     } catch (std::exception& e) {
13019       {
13020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13021       };
13022     } catch (...) {
13023       {
13024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13025       };
13026     }
13027   }
13028   jresult = result;
13029   return jresult;
13030 }
13031
13032
13033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13034   unsigned int jresult ;
13035   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13036   Dali::Property::Key *arg2 = 0 ;
13037   bool result;
13038
13039   arg1 = (Dali::Property::Key *)jarg1;
13040   arg2 = (Dali::Property::Key *)jarg2;
13041   if (!arg2) {
13042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13043     return 0;
13044   }
13045   {
13046     try {
13047       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13048     } catch (std::out_of_range& e) {
13049       {
13050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13051       };
13052     } catch (std::exception& e) {
13053       {
13054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13055       };
13056     } catch (...) {
13057       {
13058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13059       };
13060     }
13061   }
13062   jresult = result;
13063   return jresult;
13064 }
13065
13066
13067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13068   unsigned int jresult ;
13069   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13070   std::string *arg2 = 0 ;
13071   bool result;
13072
13073   arg1 = (Dali::Property::Key *)jarg1;
13074   if (!jarg2) {
13075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13076     return 0;
13077   }
13078   std::string arg2_str(jarg2);
13079   arg2 = &arg2_str;
13080   {
13081     try {
13082       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13083     } catch (std::out_of_range& e) {
13084       {
13085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13086       };
13087     } catch (std::exception& e) {
13088       {
13089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13090       };
13091     } catch (...) {
13092       {
13093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13094       };
13095     }
13096   }
13097   jresult = result;
13098
13099   //argout typemap for const std::string&
13100
13101   return jresult;
13102 }
13103
13104
13105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13106   unsigned int jresult ;
13107   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13108   Dali::Property::Index arg2 ;
13109   bool result;
13110
13111   arg1 = (Dali::Property::Key *)jarg1;
13112   arg2 = (Dali::Property::Index)jarg2;
13113   {
13114     try {
13115       result = (bool)(arg1)->operator !=(arg2);
13116     } catch (std::out_of_range& e) {
13117       {
13118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13119       };
13120     } catch (std::exception& e) {
13121       {
13122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13123       };
13124     } catch (...) {
13125       {
13126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13127       };
13128     }
13129   }
13130   jresult = result;
13131   return jresult;
13132 }
13133
13134
13135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13136   unsigned int jresult ;
13137   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13138   Dali::Property::Key *arg2 = 0 ;
13139   bool result;
13140
13141   arg1 = (Dali::Property::Key *)jarg1;
13142   arg2 = (Dali::Property::Key *)jarg2;
13143   if (!arg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13145     return 0;
13146   }
13147   {
13148     try {
13149       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13150     } catch (std::out_of_range& e) {
13151       {
13152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13153       };
13154     } catch (std::exception& e) {
13155       {
13156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13157       };
13158     } catch (...) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13161       };
13162     }
13163   }
13164   jresult = result;
13165   return jresult;
13166 }
13167
13168
13169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13170   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13171
13172   arg1 = (Dali::Property::Key *)jarg1;
13173   {
13174     try {
13175       delete arg1;
13176     } catch (std::out_of_range& e) {
13177       {
13178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13179       };
13180     } catch (std::exception& e) {
13181       {
13182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13183       };
13184     } catch (...) {
13185       {
13186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13187       };
13188     }
13189   }
13190 }
13191
13192
13193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13194   void * jresult ;
13195   Dali::Property::Map *result = 0 ;
13196
13197   {
13198     try {
13199       result = (Dali::Property::Map *)new Dali::Property::Map();
13200     } catch (std::out_of_range& e) {
13201       {
13202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13203       };
13204     } catch (std::exception& e) {
13205       {
13206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13207       };
13208     } catch (...) {
13209       {
13210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13211       };
13212     }
13213   }
13214   jresult = (void *)result;
13215   return jresult;
13216 }
13217
13218
13219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
13220   void * jresult ;
13221   Dali::Property::Map *arg1 = 0 ;
13222   Dali::Property::Map *result = 0 ;
13223
13224   arg1 = (Dali::Property::Map *)jarg1;
13225   if (!arg1) {
13226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13227     return 0;
13228   }
13229   {
13230     try {
13231       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
13232     } catch (std::out_of_range& e) {
13233       {
13234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13235       };
13236     } catch (std::exception& e) {
13237       {
13238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13239       };
13240     } catch (...) {
13241       {
13242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13243       };
13244     }
13245   }
13246   jresult = (void *)result;
13247   return jresult;
13248 }
13249
13250
13251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
13252   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13253
13254   arg1 = (Dali::Property::Map *)jarg1;
13255   {
13256     try {
13257       delete arg1;
13258     } catch (std::out_of_range& e) {
13259       {
13260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13261       };
13262     } catch (std::exception& e) {
13263       {
13264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13265       };
13266     } catch (...) {
13267       {
13268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13269       };
13270     }
13271   }
13272 }
13273
13274
13275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
13276   unsigned long jresult ;
13277   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13278   Dali::Property::Map::SizeType result;
13279
13280   arg1 = (Dali::Property::Map *)jarg1;
13281   {
13282     try {
13283       result = ((Dali::Property::Map const *)arg1)->Count();
13284     } catch (std::out_of_range& e) {
13285       {
13286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13287       };
13288     } catch (std::exception& e) {
13289       {
13290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13291       };
13292     } catch (...) {
13293       {
13294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13295       };
13296     }
13297   }
13298   jresult = (unsigned long)result;
13299   return jresult;
13300 }
13301
13302
13303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
13304   unsigned int jresult ;
13305   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13306   bool result;
13307
13308   arg1 = (Dali::Property::Map *)jarg1;
13309   {
13310     try {
13311       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
13312     } catch (std::out_of_range& e) {
13313       {
13314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13315       };
13316     } catch (std::exception& e) {
13317       {
13318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13319       };
13320     } catch (...) {
13321       {
13322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13323       };
13324     }
13325   }
13326   jresult = result;
13327   return jresult;
13328 }
13329
13330
13331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
13332   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13333   char *arg2 = (char *) 0 ;
13334   Dali::Property::Value *arg3 = 0 ;
13335
13336   arg1 = (Dali::Property::Map *)jarg1;
13337   arg2 = (char *)jarg2;
13338   arg3 = (Dali::Property::Value *)jarg3;
13339   if (!arg3) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13341     return ;
13342   }
13343   {
13344     try {
13345       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
13346     } catch (std::out_of_range& e) {
13347       {
13348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (std::exception& e) {
13351       {
13352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13353       };
13354     } catch (...) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13357       };
13358     }
13359   }
13360 }
13361
13362
13363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
13364   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13365   Dali::Property::Index arg2 ;
13366   Dali::Property::Value *arg3 = 0 ;
13367
13368   arg1 = (Dali::Property::Map *)jarg1;
13369   arg2 = (Dali::Property::Index)jarg2;
13370   arg3 = (Dali::Property::Value *)jarg3;
13371   if (!arg3) {
13372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13373     return ;
13374   }
13375   {
13376     try {
13377       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
13378     } catch (std::out_of_range& e) {
13379       {
13380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13381       };
13382     } catch (std::exception& e) {
13383       {
13384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13385       };
13386     } catch (...) {
13387       {
13388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13389       };
13390     }
13391   }
13392 }
13393
13394
13395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
13396   void * jresult ;
13397   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13398   char *arg2 = (char *) 0 ;
13399   Dali::Property::Value *arg3 = 0 ;
13400   Dali::Property::Map *result = 0 ;
13401
13402   arg1 = (Dali::Property::Map *)jarg1;
13403   arg2 = (char *)jarg2;
13404   arg3 = (Dali::Property::Value *)jarg3;
13405   if (!arg3) {
13406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13407     return 0;
13408   }
13409   {
13410     try {
13411       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
13412     } catch (std::out_of_range& e) {
13413       {
13414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13415       };
13416     } catch (std::exception& e) {
13417       {
13418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13419       };
13420     } catch (...) {
13421       {
13422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13423       };
13424     }
13425   }
13426   jresult = (void *)result;
13427   return jresult;
13428 }
13429
13430
13431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
13432   void * jresult ;
13433   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13434   Dali::Property::Index arg2 ;
13435   Dali::Property::Value *arg3 = 0 ;
13436   Dali::Property::Map *result = 0 ;
13437
13438   arg1 = (Dali::Property::Map *)jarg1;
13439   arg2 = (Dali::Property::Index)jarg2;
13440   arg3 = (Dali::Property::Value *)jarg3;
13441   if (!arg3) {
13442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13443     return 0;
13444   }
13445   {
13446     try {
13447       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
13448     } catch (std::out_of_range& e) {
13449       {
13450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13451       };
13452     } catch (std::exception& e) {
13453       {
13454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13455       };
13456     } catch (...) {
13457       {
13458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13459       };
13460     }
13461   }
13462   jresult = (void *)result;
13463   return jresult;
13464 }
13465
13466
13467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
13468   void * jresult ;
13469   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13470   Dali::Property::Map::SizeType arg2 ;
13471   Dali::Property::Value *result = 0 ;
13472
13473   arg1 = (Dali::Property::Map *)jarg1;
13474   arg2 = (Dali::Property::Map::SizeType)jarg2;
13475   {
13476     try {
13477       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
13478     } catch (std::out_of_range& e) {
13479       {
13480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13481       };
13482     } catch (std::exception& e) {
13483       {
13484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13485       };
13486     } catch (...) {
13487       {
13488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13489       };
13490     }
13491   }
13492   jresult = (void *)result;
13493   return jresult;
13494 }
13495
13496
13497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
13498   char * jresult ;
13499   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13500   Dali::Property::Map::SizeType arg2 ;
13501   std::string *result = 0 ;
13502
13503   arg1 = (Dali::Property::Map *)jarg1;
13504   arg2 = (Dali::Property::Map::SizeType)jarg2;
13505   {
13506     try {
13507       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
13508     } catch (std::out_of_range& e) {
13509       {
13510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13511       };
13512     } catch (std::exception& e) {
13513       {
13514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13515       };
13516     } catch (...) {
13517       {
13518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13519       };
13520     }
13521   }
13522   jresult = SWIG_csharp_string_callback(result->c_str());
13523   return jresult;
13524 }
13525
13526
13527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
13528   void * jresult ;
13529   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13530   Dali::Property::Map::SizeType arg2 ;
13531   SwigValueWrapper< Dali::Property::Key > result;
13532
13533   arg1 = (Dali::Property::Map *)jarg1;
13534   arg2 = (Dali::Property::Map::SizeType)jarg2;
13535   {
13536     try {
13537       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
13538     } catch (std::out_of_range& e) {
13539       {
13540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13541       };
13542     } catch (std::exception& e) {
13543       {
13544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13545       };
13546     } catch (...) {
13547       {
13548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13549       };
13550     }
13551   }
13552   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
13553   return jresult;
13554 }
13555
13556
13557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
13558   void * jresult ;
13559   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13560   Dali::Property::Map::SizeType arg2 ;
13561   StringValuePair *result = 0 ;
13562
13563   arg1 = (Dali::Property::Map *)jarg1;
13564   arg2 = (Dali::Property::Map::SizeType)jarg2;
13565   {
13566     try {
13567       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
13568     } catch (std::out_of_range& e) {
13569       {
13570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13571       };
13572     } catch (std::exception& e) {
13573       {
13574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13575       };
13576     } catch (...) {
13577       {
13578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13579       };
13580     }
13581   }
13582   jresult = (void *)result;
13583   return jresult;
13584 }
13585
13586
13587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
13588   void * jresult ;
13589   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13590   char *arg2 = (char *) 0 ;
13591   Dali::Property::Value *result = 0 ;
13592
13593   arg1 = (Dali::Property::Map *)jarg1;
13594   arg2 = (char *)jarg2;
13595   {
13596     try {
13597       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
13598     } catch (std::out_of_range& e) {
13599       {
13600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13601       };
13602     } catch (std::exception& e) {
13603       {
13604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13605       };
13606     } catch (...) {
13607       {
13608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13609       };
13610     }
13611   }
13612   jresult = (void *)result;
13613   return jresult;
13614 }
13615
13616
13617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
13618   void * jresult ;
13619   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13620   Dali::Property::Index arg2 ;
13621   Dali::Property::Value *result = 0 ;
13622
13623   arg1 = (Dali::Property::Map *)jarg1;
13624   arg2 = (Dali::Property::Index)jarg2;
13625   {
13626     try {
13627       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
13628     } catch (std::out_of_range& e) {
13629       {
13630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13631       };
13632     } catch (std::exception& e) {
13633       {
13634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13635       };
13636     } catch (...) {
13637       {
13638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13639       };
13640     }
13641   }
13642   jresult = (void *)result;
13643   return jresult;
13644 }
13645
13646
13647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
13648   void * jresult ;
13649   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13650   Dali::Property::Index arg2 ;
13651   std::string *arg3 = 0 ;
13652   Dali::Property::Value *result = 0 ;
13653
13654   arg1 = (Dali::Property::Map *)jarg1;
13655   arg2 = (Dali::Property::Index)jarg2;
13656   if (!jarg3) {
13657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13658     return 0;
13659   }
13660   std::string arg3_str(jarg3);
13661   arg3 = &arg3_str;
13662   {
13663     try {
13664       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
13665     } catch (std::out_of_range& e) {
13666       {
13667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13668       };
13669     } catch (std::exception& e) {
13670       {
13671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13672       };
13673     } catch (...) {
13674       {
13675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13676       };
13677     }
13678   }
13679   jresult = (void *)result;
13680
13681   //argout typemap for const std::string&
13682
13683   return jresult;
13684 }
13685
13686
13687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
13688   void * jresult ;
13689   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13690   std::string *arg2 = 0 ;
13691   Dali::Property::Type arg3 ;
13692   Dali::Property::Value *result = 0 ;
13693
13694   arg1 = (Dali::Property::Map *)jarg1;
13695   if (!jarg2) {
13696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13697     return 0;
13698   }
13699   std::string arg2_str(jarg2);
13700   arg2 = &arg2_str;
13701   arg3 = (Dali::Property::Type)jarg3;
13702   {
13703     try {
13704       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
13705     } catch (std::out_of_range& e) {
13706       {
13707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13708       };
13709     } catch (std::exception& e) {
13710       {
13711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13712       };
13713     } catch (...) {
13714       {
13715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13716       };
13717     }
13718   }
13719   jresult = (void *)result;
13720
13721   //argout typemap for const std::string&
13722
13723   return jresult;
13724 }
13725
13726
13727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
13728   void * jresult ;
13729   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13730   Dali::Property::Index arg2 ;
13731   Dali::Property::Type arg3 ;
13732   Dali::Property::Value *result = 0 ;
13733
13734   arg1 = (Dali::Property::Map *)jarg1;
13735   arg2 = (Dali::Property::Index)jarg2;
13736   arg3 = (Dali::Property::Type)jarg3;
13737   {
13738     try {
13739       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
13740     } catch (std::out_of_range& e) {
13741       {
13742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13743       };
13744     } catch (std::exception& e) {
13745       {
13746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13747       };
13748     } catch (...) {
13749       {
13750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13751       };
13752     }
13753   }
13754   jresult = (void *)result;
13755   return jresult;
13756 }
13757
13758
13759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
13760   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13761
13762   arg1 = (Dali::Property::Map *)jarg1;
13763   {
13764     try {
13765       (arg1)->Clear();
13766     } catch (std::out_of_range& e) {
13767       {
13768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13769       };
13770     } catch (std::exception& e) {
13771       {
13772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13773       };
13774     } catch (...) {
13775       {
13776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13777       };
13778     }
13779   }
13780 }
13781
13782
13783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
13784   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13785   Dali::Property::Map *arg2 = 0 ;
13786
13787   arg1 = (Dali::Property::Map *)jarg1;
13788   arg2 = (Dali::Property::Map *)jarg2;
13789   if (!arg2) {
13790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13791     return ;
13792   }
13793   {
13794     try {
13795       (arg1)->Merge((Dali::Property::Map const &)*arg2);
13796     } catch (std::out_of_range& e) {
13797       {
13798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13799       };
13800     } catch (std::exception& e) {
13801       {
13802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13803       };
13804     } catch (...) {
13805       {
13806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13807       };
13808     }
13809   }
13810 }
13811
13812
13813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
13814   void * jresult ;
13815   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13816   std::string *arg2 = 0 ;
13817   Dali::Property::Value *result = 0 ;
13818
13819   arg1 = (Dali::Property::Map *)jarg1;
13820   if (!jarg2) {
13821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13822     return 0;
13823   }
13824   std::string arg2_str(jarg2);
13825   arg2 = &arg2_str;
13826   {
13827     try {
13828       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
13829     } catch (std::out_of_range& e) {
13830       {
13831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13832       };
13833     } catch (std::exception& e) {
13834       {
13835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13836       };
13837     } catch (...) {
13838       {
13839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13840       };
13841     }
13842   }
13843   jresult = (void *)result;
13844
13845   //argout typemap for const std::string&
13846
13847   return jresult;
13848 }
13849
13850
13851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
13852   void * jresult ;
13853   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13854   Dali::Property::Index arg2 ;
13855   Dali::Property::Value *result = 0 ;
13856
13857   arg1 = (Dali::Property::Map *)jarg1;
13858   arg2 = (Dali::Property::Index)jarg2;
13859   {
13860     try {
13861       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
13862     } catch (std::out_of_range& e) {
13863       {
13864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13865       };
13866     } catch (std::exception& e) {
13867       {
13868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13869       };
13870     } catch (...) {
13871       {
13872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13873       };
13874     }
13875   }
13876   jresult = (void *)result;
13877   return jresult;
13878 }
13879
13880
13881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
13882   void * jresult ;
13883   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
13884   Dali::Property::Map *arg2 = 0 ;
13885   Dali::Property::Map *result = 0 ;
13886
13887   arg1 = (Dali::Property::Map *)jarg1;
13888   arg2 = (Dali::Property::Map *)jarg2;
13889   if (!arg2) {
13890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13891     return 0;
13892   }
13893   {
13894     try {
13895       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
13896     } catch (std::out_of_range& e) {
13897       {
13898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13899       };
13900     } catch (std::exception& e) {
13901       {
13902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13903       };
13904     } catch (...) {
13905       {
13906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13907       };
13908     }
13909   }
13910   jresult = (void *)result;
13911   return jresult;
13912 }
13913
13914
13915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
13916   void * jresult ;
13917   Dali::Property::Value *result = 0 ;
13918
13919   {
13920     try {
13921       result = (Dali::Property::Value *)new Dali::Property::Value();
13922     } catch (std::out_of_range& e) {
13923       {
13924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13925       };
13926     } catch (std::exception& e) {
13927       {
13928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13929       };
13930     } catch (...) {
13931       {
13932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13933       };
13934     }
13935   }
13936   jresult = (void *)result;
13937   return jresult;
13938 }
13939
13940
13941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
13942   void * jresult ;
13943   bool arg1 ;
13944   Dali::Property::Value *result = 0 ;
13945
13946   arg1 = jarg1 ? true : false;
13947   {
13948     try {
13949       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
13950     } catch (std::out_of_range& e) {
13951       {
13952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13953       };
13954     } catch (std::exception& e) {
13955       {
13956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13957       };
13958     } catch (...) {
13959       {
13960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13961       };
13962     }
13963   }
13964   jresult = (void *)result;
13965   return jresult;
13966 }
13967
13968
13969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
13970   void * jresult ;
13971   int arg1 ;
13972   Dali::Property::Value *result = 0 ;
13973
13974   arg1 = (int)jarg1;
13975   {
13976     try {
13977       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
13978     } catch (std::out_of_range& e) {
13979       {
13980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13981       };
13982     } catch (std::exception& e) {
13983       {
13984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13985       };
13986     } catch (...) {
13987       {
13988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13989       };
13990     }
13991   }
13992   jresult = (void *)result;
13993   return jresult;
13994 }
13995
13996
13997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
13998   void * jresult ;
13999   float arg1 ;
14000   Dali::Property::Value *result = 0 ;
14001
14002   arg1 = (float)jarg1;
14003   {
14004     try {
14005       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14006     } catch (std::out_of_range& e) {
14007       {
14008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14009       };
14010     } catch (std::exception& e) {
14011       {
14012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14013       };
14014     } catch (...) {
14015       {
14016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14017       };
14018     }
14019   }
14020   jresult = (void *)result;
14021   return jresult;
14022 }
14023
14024
14025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14026   void * jresult ;
14027   Dali::Vector2 *arg1 = 0 ;
14028   Dali::Property::Value *result = 0 ;
14029
14030   arg1 = (Dali::Vector2 *)jarg1;
14031   if (!arg1) {
14032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14033     return 0;
14034   }
14035   {
14036     try {
14037       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14038     } catch (std::out_of_range& e) {
14039       {
14040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14041       };
14042     } catch (std::exception& e) {
14043       {
14044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14045       };
14046     } catch (...) {
14047       {
14048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14049       };
14050     }
14051   }
14052   jresult = (void *)result;
14053   return jresult;
14054 }
14055
14056
14057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14058   void * jresult ;
14059   Dali::Vector3 *arg1 = 0 ;
14060   Dali::Property::Value *result = 0 ;
14061
14062   arg1 = (Dali::Vector3 *)jarg1;
14063   if (!arg1) {
14064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14065     return 0;
14066   }
14067   {
14068     try {
14069       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14070     } catch (std::out_of_range& e) {
14071       {
14072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14073       };
14074     } catch (std::exception& e) {
14075       {
14076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14077       };
14078     } catch (...) {
14079       {
14080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14081       };
14082     }
14083   }
14084   jresult = (void *)result;
14085   return jresult;
14086 }
14087
14088
14089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14090   void * jresult ;
14091   Dali::Vector4 *arg1 = 0 ;
14092   Dali::Property::Value *result = 0 ;
14093
14094   arg1 = (Dali::Vector4 *)jarg1;
14095   if (!arg1) {
14096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14097     return 0;
14098   }
14099   {
14100     try {
14101       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14102     } catch (std::out_of_range& e) {
14103       {
14104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14105       };
14106     } catch (std::exception& e) {
14107       {
14108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14109       };
14110     } catch (...) {
14111       {
14112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14113       };
14114     }
14115   }
14116   jresult = (void *)result;
14117   return jresult;
14118 }
14119
14120
14121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14122   void * jresult ;
14123   Dali::Matrix3 *arg1 = 0 ;
14124   Dali::Property::Value *result = 0 ;
14125
14126   arg1 = (Dali::Matrix3 *)jarg1;
14127   if (!arg1) {
14128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14129     return 0;
14130   }
14131   {
14132     try {
14133       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14134     } catch (std::out_of_range& e) {
14135       {
14136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (std::exception& e) {
14139       {
14140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14141       };
14142     } catch (...) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14145       };
14146     }
14147   }
14148   jresult = (void *)result;
14149   return jresult;
14150 }
14151
14152
14153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14154   void * jresult ;
14155   Dali::Matrix *arg1 = 0 ;
14156   Dali::Property::Value *result = 0 ;
14157
14158   arg1 = (Dali::Matrix *)jarg1;
14159   if (!arg1) {
14160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14161     return 0;
14162   }
14163   {
14164     try {
14165       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14166     } catch (std::out_of_range& e) {
14167       {
14168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14169       };
14170     } catch (std::exception& e) {
14171       {
14172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14173       };
14174     } catch (...) {
14175       {
14176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14177       };
14178     }
14179   }
14180   jresult = (void *)result;
14181   return jresult;
14182 }
14183
14184
14185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14186   void * jresult ;
14187   Dali::Rect< int > *arg1 = 0 ;
14188   Dali::Property::Value *result = 0 ;
14189
14190   arg1 = (Dali::Rect< int > *)jarg1;
14191   if (!arg1) {
14192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14193     return 0;
14194   }
14195   {
14196     try {
14197       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14198     } catch (std::out_of_range& e) {
14199       {
14200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14201       };
14202     } catch (std::exception& e) {
14203       {
14204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14205       };
14206     } catch (...) {
14207       {
14208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14209       };
14210     }
14211   }
14212   jresult = (void *)result;
14213   return jresult;
14214 }
14215
14216
14217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
14218   void * jresult ;
14219   Dali::AngleAxis *arg1 = 0 ;
14220   Dali::Property::Value *result = 0 ;
14221
14222   arg1 = (Dali::AngleAxis *)jarg1;
14223   if (!arg1) {
14224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14225     return 0;
14226   }
14227   {
14228     try {
14229       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
14230     } catch (std::out_of_range& e) {
14231       {
14232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14233       };
14234     } catch (std::exception& e) {
14235       {
14236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14237       };
14238     } catch (...) {
14239       {
14240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14241       };
14242     }
14243   }
14244   jresult = (void *)result;
14245   return jresult;
14246 }
14247
14248
14249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
14250   void * jresult ;
14251   Dali::Quaternion *arg1 = 0 ;
14252   Dali::Property::Value *result = 0 ;
14253
14254   arg1 = (Dali::Quaternion *)jarg1;
14255   if (!arg1) {
14256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
14257     return 0;
14258   }
14259   {
14260     try {
14261       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
14262     } catch (std::out_of_range& e) {
14263       {
14264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14265       };
14266     } catch (std::exception& e) {
14267       {
14268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14269       };
14270     } catch (...) {
14271       {
14272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14273       };
14274     }
14275   }
14276   jresult = (void *)result;
14277   return jresult;
14278 }
14279
14280
14281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
14282   void * jresult ;
14283   std::string *arg1 = 0 ;
14284   Dali::Property::Value *result = 0 ;
14285
14286   if (!jarg1) {
14287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14288     return 0;
14289   }
14290   std::string arg1_str(jarg1);
14291   arg1 = &arg1_str;
14292   {
14293     try {
14294       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
14295     } catch (std::out_of_range& e) {
14296       {
14297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14298       };
14299     } catch (std::exception& e) {
14300       {
14301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14302       };
14303     } catch (...) {
14304       {
14305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14306       };
14307     }
14308   }
14309   jresult = (void *)result;
14310
14311   //argout typemap for const std::string&
14312
14313   return jresult;
14314 }
14315
14316
14317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
14318   void * jresult ;
14319   Dali::Property::Array *arg1 = 0 ;
14320   Dali::Property::Value *result = 0 ;
14321
14322   arg1 = (Dali::Property::Array *)jarg1;
14323   if (!arg1) {
14324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
14325     return 0;
14326   }
14327   {
14328     try {
14329       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
14330     } catch (std::out_of_range& e) {
14331       {
14332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14333       };
14334     } catch (std::exception& e) {
14335       {
14336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14337       };
14338     } catch (...) {
14339       {
14340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14341       };
14342     }
14343   }
14344   jresult = (void *)result;
14345   return jresult;
14346 }
14347
14348
14349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
14350   void * jresult ;
14351   Dali::Property::Map *arg1 = 0 ;
14352   Dali::Property::Value *result = 0 ;
14353
14354   arg1 = (Dali::Property::Map *)jarg1;
14355   if (!arg1) {
14356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
14357     return 0;
14358   }
14359   {
14360     try {
14361       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
14362     } catch (std::out_of_range& e) {
14363       {
14364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14365       };
14366     } catch (std::exception& e) {
14367       {
14368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14369       };
14370     } catch (...) {
14371       {
14372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14373       };
14374     }
14375   }
14376   jresult = (void *)result;
14377   return jresult;
14378 }
14379
14380
14381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
14382   void * jresult ;
14383   Dali::Property::Type arg1 ;
14384   Dali::Property::Value *result = 0 ;
14385
14386   arg1 = (Dali::Property::Type)jarg1;
14387   {
14388     try {
14389       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14390     } catch (std::out_of_range& e) {
14391       {
14392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14393       };
14394     } catch (std::exception& e) {
14395       {
14396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14397       };
14398     } catch (...) {
14399       {
14400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14401       };
14402     }
14403   }
14404   jresult = (void *)result;
14405   return jresult;
14406 }
14407
14408
14409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
14410   void * jresult ;
14411   Dali::Property::Value *arg1 = 0 ;
14412   Dali::Property::Value *result = 0 ;
14413
14414   arg1 = (Dali::Property::Value *)jarg1;
14415   if (!arg1) {
14416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14417     return 0;
14418   }
14419   {
14420     try {
14421       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
14422     } catch (std::out_of_range& e) {
14423       {
14424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14425       };
14426     } catch (std::exception& e) {
14427       {
14428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14429       };
14430     } catch (...) {
14431       {
14432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14433       };
14434     }
14435   }
14436   jresult = (void *)result;
14437   return jresult;
14438 }
14439
14440
14441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
14442   void * jresult ;
14443   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14444   Dali::Property::Value *arg2 = 0 ;
14445   Dali::Property::Value *result = 0 ;
14446
14447   arg1 = (Dali::Property::Value *)jarg1;
14448   arg2 = (Dali::Property::Value *)jarg2;
14449   if (!arg2) {
14450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14451     return 0;
14452   }
14453   {
14454     try {
14455       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
14456     } catch (std::out_of_range& e) {
14457       {
14458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14459       };
14460     } catch (std::exception& e) {
14461       {
14462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14463       };
14464     } catch (...) {
14465       {
14466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14467       };
14468     }
14469   }
14470   jresult = (void *)result;
14471   return jresult;
14472 }
14473
14474
14475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
14476   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14477
14478   arg1 = (Dali::Property::Value *)jarg1;
14479   {
14480     try {
14481       delete arg1;
14482     } catch (std::out_of_range& e) {
14483       {
14484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14485       };
14486     } catch (std::exception& e) {
14487       {
14488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14489       };
14490     } catch (...) {
14491       {
14492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14493       };
14494     }
14495   }
14496 }
14497
14498
14499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
14500   int jresult ;
14501   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14502   Dali::Property::Type result;
14503
14504   arg1 = (Dali::Property::Value *)jarg1;
14505   {
14506     try {
14507       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
14508     } catch (std::out_of_range& e) {
14509       {
14510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14511       };
14512     } catch (std::exception& e) {
14513       {
14514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14515       };
14516     } catch (...) {
14517       {
14518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14519       };
14520     }
14521   }
14522   jresult = (int)result;
14523   return jresult;
14524 }
14525
14526
14527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
14528   unsigned int jresult ;
14529   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14530   bool *arg2 = 0 ;
14531   bool result;
14532
14533   arg1 = (Dali::Property::Value *)jarg1;
14534   arg2 = (bool *)jarg2;
14535   {
14536     try {
14537       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14538     } catch (std::out_of_range& e) {
14539       {
14540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14541       };
14542     } catch (std::exception& e) {
14543       {
14544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14545       };
14546     } catch (...) {
14547       {
14548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14549       };
14550     }
14551   }
14552   jresult = result;
14553   return jresult;
14554 }
14555
14556
14557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
14558   unsigned int jresult ;
14559   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14560   float *arg2 = 0 ;
14561   bool result;
14562
14563   arg1 = (Dali::Property::Value *)jarg1;
14564   arg2 = (float *)jarg2;
14565   {
14566     try {
14567       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14568     } catch (std::out_of_range& e) {
14569       {
14570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14571       };
14572     } catch (std::exception& e) {
14573       {
14574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14575       };
14576     } catch (...) {
14577       {
14578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14579       };
14580     }
14581   }
14582   jresult = result;
14583   return jresult;
14584 }
14585
14586
14587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
14588   unsigned int jresult ;
14589   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14590   int *arg2 = 0 ;
14591   bool result;
14592
14593   arg1 = (Dali::Property::Value *)jarg1;
14594   arg2 = (int *)jarg2;
14595   {
14596     try {
14597       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14598     } catch (std::out_of_range& e) {
14599       {
14600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14601       };
14602     } catch (std::exception& e) {
14603       {
14604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14605       };
14606     } catch (...) {
14607       {
14608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14609       };
14610     }
14611   }
14612   jresult = result;
14613   return jresult;
14614 }
14615
14616
14617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
14618   unsigned int jresult ;
14619   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14620   Dali::Rect< int > *arg2 = 0 ;
14621   bool result;
14622
14623   arg1 = (Dali::Property::Value *)jarg1;
14624   arg2 = (Dali::Rect< int > *)jarg2;
14625   if (!arg2) {
14626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
14627     return 0;
14628   }
14629   {
14630     try {
14631       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14632     } catch (std::out_of_range& e) {
14633       {
14634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14635       };
14636     } catch (std::exception& e) {
14637       {
14638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14639       };
14640     } catch (...) {
14641       {
14642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14643       };
14644     }
14645   }
14646   jresult = result;
14647   return jresult;
14648 }
14649
14650
14651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
14652   unsigned int jresult ;
14653   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14654   Dali::Vector2 *arg2 = 0 ;
14655   bool result;
14656
14657   arg1 = (Dali::Property::Value *)jarg1;
14658   arg2 = (Dali::Vector2 *)jarg2;
14659   if (!arg2) {
14660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
14661     return 0;
14662   }
14663   {
14664     try {
14665       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14666     } catch (std::out_of_range& e) {
14667       {
14668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14669       };
14670     } catch (std::exception& e) {
14671       {
14672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14673       };
14674     } catch (...) {
14675       {
14676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14677       };
14678     }
14679   }
14680   jresult = result;
14681   return jresult;
14682 }
14683
14684
14685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
14686   unsigned int jresult ;
14687   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14688   Dali::Vector3 *arg2 = 0 ;
14689   bool result;
14690
14691   arg1 = (Dali::Property::Value *)jarg1;
14692   arg2 = (Dali::Vector3 *)jarg2;
14693   if (!arg2) {
14694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
14695     return 0;
14696   }
14697   {
14698     try {
14699       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14700     } catch (std::out_of_range& e) {
14701       {
14702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14703       };
14704     } catch (std::exception& e) {
14705       {
14706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14707       };
14708     } catch (...) {
14709       {
14710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14711       };
14712     }
14713   }
14714   jresult = result;
14715   return jresult;
14716 }
14717
14718
14719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
14720   unsigned int jresult ;
14721   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14722   Dali::Vector4 *arg2 = 0 ;
14723   bool result;
14724
14725   arg1 = (Dali::Property::Value *)jarg1;
14726   arg2 = (Dali::Vector4 *)jarg2;
14727   if (!arg2) {
14728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
14729     return 0;
14730   }
14731   {
14732     try {
14733       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14734     } catch (std::out_of_range& e) {
14735       {
14736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14737       };
14738     } catch (std::exception& e) {
14739       {
14740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14741       };
14742     } catch (...) {
14743       {
14744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14745       };
14746     }
14747   }
14748   jresult = result;
14749   return jresult;
14750 }
14751
14752
14753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
14754   unsigned int jresult ;
14755   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14756   Dali::Matrix3 *arg2 = 0 ;
14757   bool result;
14758
14759   arg1 = (Dali::Property::Value *)jarg1;
14760   arg2 = (Dali::Matrix3 *)jarg2;
14761   if (!arg2) {
14762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
14763     return 0;
14764   }
14765   {
14766     try {
14767       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14768     } catch (std::out_of_range& e) {
14769       {
14770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (std::exception& e) {
14773       {
14774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14775       };
14776     } catch (...) {
14777       {
14778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14779       };
14780     }
14781   }
14782   jresult = result;
14783   return jresult;
14784 }
14785
14786
14787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
14788   unsigned int jresult ;
14789   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14790   Dali::Matrix *arg2 = 0 ;
14791   bool result;
14792
14793   arg1 = (Dali::Property::Value *)jarg1;
14794   arg2 = (Dali::Matrix *)jarg2;
14795   if (!arg2) {
14796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
14797     return 0;
14798   }
14799   {
14800     try {
14801       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14802     } catch (std::out_of_range& e) {
14803       {
14804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14805       };
14806     } catch (std::exception& e) {
14807       {
14808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14809       };
14810     } catch (...) {
14811       {
14812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14813       };
14814     }
14815   }
14816   jresult = result;
14817   return jresult;
14818 }
14819
14820
14821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
14822   unsigned int jresult ;
14823   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14824   Dali::AngleAxis *arg2 = 0 ;
14825   bool result;
14826
14827   arg1 = (Dali::Property::Value *)jarg1;
14828   arg2 = (Dali::AngleAxis *)jarg2;
14829   if (!arg2) {
14830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
14831     return 0;
14832   }
14833   {
14834     try {
14835       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14836     } catch (std::out_of_range& e) {
14837       {
14838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14839       };
14840     } catch (std::exception& e) {
14841       {
14842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14843       };
14844     } catch (...) {
14845       {
14846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14847       };
14848     }
14849   }
14850   jresult = result;
14851   return jresult;
14852 }
14853
14854
14855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
14856   unsigned int jresult ;
14857   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14858   Dali::Quaternion *arg2 = 0 ;
14859   bool result;
14860
14861   arg1 = (Dali::Property::Value *)jarg1;
14862   arg2 = (Dali::Quaternion *)jarg2;
14863   if (!arg2) {
14864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
14865     return 0;
14866   }
14867   {
14868     try {
14869       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14870     } catch (std::out_of_range& e) {
14871       {
14872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14873       };
14874     } catch (std::exception& e) {
14875       {
14876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14877       };
14878     } catch (...) {
14879       {
14880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14881       };
14882     }
14883   }
14884   jresult = result;
14885   return jresult;
14886 }
14887
14888
14889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
14890   unsigned int jresult ;
14891   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14892   std::string *arg2 = 0 ;
14893   bool result;
14894
14895   arg1 = (Dali::Property::Value *)jarg1;
14896
14897   //typemap in
14898   std::string temp;
14899   arg2 = &temp;
14900
14901   {
14902     try {
14903       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14904     } catch (std::out_of_range& e) {
14905       {
14906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14907       };
14908     } catch (std::exception& e) {
14909       {
14910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14911       };
14912     } catch (...) {
14913       {
14914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14915       };
14916     }
14917   }
14918   jresult = result;
14919
14920   //Typemap argout in c++ file.
14921   //This will convert c++ string to c# string
14922   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
14923
14924   return jresult;
14925 }
14926
14927
14928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
14929   unsigned int jresult ;
14930   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14931   Dali::Property::Array *arg2 = 0 ;
14932   bool result;
14933
14934   arg1 = (Dali::Property::Value *)jarg1;
14935   arg2 = (Dali::Property::Array *)jarg2;
14936   if (!arg2) {
14937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
14938     return 0;
14939   }
14940   {
14941     try {
14942       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14943     } catch (std::out_of_range& e) {
14944       {
14945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14946       };
14947     } catch (std::exception& e) {
14948       {
14949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14950       };
14951     } catch (...) {
14952       {
14953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14954       };
14955     }
14956   }
14957   jresult = result;
14958   return jresult;
14959 }
14960
14961
14962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
14963   unsigned int jresult ;
14964   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14965   Dali::Property::Map *arg2 = 0 ;
14966   bool result;
14967
14968   arg1 = (Dali::Property::Value *)jarg1;
14969   arg2 = (Dali::Property::Map *)jarg2;
14970   if (!arg2) {
14971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
14972     return 0;
14973   }
14974   {
14975     try {
14976       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
14977     } catch (std::out_of_range& e) {
14978       {
14979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14980       };
14981     } catch (std::exception& e) {
14982       {
14983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14984       };
14985     } catch (...) {
14986       {
14987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14988       };
14989     }
14990   }
14991   jresult = result;
14992   return jresult;
14993 }
14994
14995
14996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
14997   void * jresult ;
14998   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
14999   Dali::Property::Array *result = 0 ;
15000
15001   arg1 = (Dali::Property::Value *)jarg1;
15002   {
15003     try {
15004       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15005     } catch (std::out_of_range& e) {
15006       {
15007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15008       };
15009     } catch (std::exception& e) {
15010       {
15011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15012       };
15013     } catch (...) {
15014       {
15015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15016       };
15017     }
15018   }
15019   jresult = (void *)result;
15020   return jresult;
15021 }
15022
15023
15024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15025   void * jresult ;
15026   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15027   Dali::Property::Map *result = 0 ;
15028
15029   arg1 = (Dali::Property::Value *)jarg1;
15030   {
15031     try {
15032       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15033     } catch (std::out_of_range& e) {
15034       {
15035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15036       };
15037     } catch (std::exception& e) {
15038       {
15039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15040       };
15041     } catch (...) {
15042       {
15043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15044       };
15045     }
15046   }
15047   jresult = (void *)result;
15048   return jresult;
15049 }
15050
15051
15052 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15053   char * jresult ;
15054   Dali::Property::Type arg1 ;
15055   char *result = 0 ;
15056
15057   arg1 = (Dali::Property::Type)jarg1;
15058   {
15059     try {
15060       result = (char *)Dali::PropertyTypes::GetName(arg1);
15061     } catch (std::out_of_range& e) {
15062       {
15063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15064       };
15065     } catch (std::exception& e) {
15066       {
15067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15068       };
15069     } catch (...) {
15070       {
15071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15072       };
15073     }
15074   }
15075   jresult = SWIG_csharp_string_callback((const char *)result);
15076   return jresult;
15077 }
15078
15079
15080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15081   unsigned int jresult ;
15082   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15083   std::string *arg2 = 0 ;
15084   Dali::Property::Map *arg3 = 0 ;
15085   bool result;
15086
15087   arg1 = (Dali::BaseObject *)jarg1;
15088   if (!jarg2) {
15089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15090     return 0;
15091   }
15092   std::string arg2_str(jarg2);
15093   arg2 = &arg2_str;
15094   arg3 = (Dali::Property::Map *)jarg3;
15095   if (!arg3) {
15096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15097     return 0;
15098   }
15099   {
15100     try {
15101       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15102     } catch (std::out_of_range& e) {
15103       {
15104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15105       };
15106     } catch (std::exception& e) {
15107       {
15108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15109       };
15110     } catch (...) {
15111       {
15112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15113       };
15114     }
15115   }
15116   jresult = result;
15117
15118   //argout typemap for const std::string&
15119
15120   return jresult;
15121 }
15122
15123
15124 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15125   char * jresult ;
15126   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15127   std::string *result = 0 ;
15128
15129   arg1 = (Dali::BaseObject *)jarg1;
15130   {
15131     try {
15132       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15133     } catch (std::out_of_range& e) {
15134       {
15135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15136       };
15137     } catch (std::exception& e) {
15138       {
15139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15140       };
15141     } catch (...) {
15142       {
15143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15144       };
15145     }
15146   }
15147   jresult = SWIG_csharp_string_callback(result->c_str());
15148   return jresult;
15149 }
15150
15151
15152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15153   unsigned int jresult ;
15154   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15155   Dali::TypeInfo *arg2 = 0 ;
15156   bool result;
15157
15158   arg1 = (Dali::BaseObject *)jarg1;
15159   arg2 = (Dali::TypeInfo *)jarg2;
15160   if (!arg2) {
15161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15162     return 0;
15163   }
15164   {
15165     try {
15166       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15167     } catch (std::out_of_range& e) {
15168       {
15169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15170       };
15171     } catch (std::exception& e) {
15172       {
15173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15174       };
15175     } catch (...) {
15176       {
15177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15178       };
15179     }
15180   }
15181   jresult = result;
15182   return jresult;
15183 }
15184
15185
15186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15187   unsigned int jresult ;
15188   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15189   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15190   std::string *arg3 = 0 ;
15191   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15192   bool result;
15193
15194   arg1 = (Dali::BaseObject *)jarg1;
15195   arg2 = (ConnectionTrackerInterface *)jarg2;
15196   if (!jarg3) {
15197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15198     return 0;
15199   }
15200   std::string arg3_str(jarg3);
15201   arg3 = &arg3_str;
15202   arg4 = (FunctorDelegate *)jarg4;
15203   {
15204     try {
15205       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15206     } catch (std::out_of_range& e) {
15207       {
15208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15209       };
15210     } catch (std::exception& e) {
15211       {
15212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15213       };
15214     } catch (...) {
15215       {
15216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15217       };
15218     }
15219   }
15220   jresult = result;
15221
15222   //argout typemap for const std::string&
15223
15224   return jresult;
15225 }
15226
15227
15228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
15229   void * jresult ;
15230   Dali::BaseHandle *arg1 = 0 ;
15231   Dali::BaseObject *result = 0 ;
15232
15233   arg1 = (Dali::BaseHandle *)jarg1;
15234   if (!arg1) {
15235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
15236     return 0;
15237   }
15238   {
15239     try {
15240       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
15241     } catch (std::out_of_range& e) {
15242       {
15243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15244       };
15245     } catch (std::exception& e) {
15246       {
15247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15248       };
15249     } catch (...) {
15250       {
15251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15252       };
15253     }
15254   }
15255   jresult = (void *)result;
15256   return jresult;
15257 }
15258
15259
15260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
15261   void * jresult ;
15262   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15263   Dali::BaseHandle *result = 0 ;
15264
15265   arg1 = (Dali::BaseObject *)jarg1;
15266   {
15267     try {
15268       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
15269     } catch (std::out_of_range& e) {
15270       {
15271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15272       };
15273     } catch (std::exception& e) {
15274       {
15275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15276       };
15277     } catch (...) {
15278       {
15279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15280       };
15281     }
15282   }
15283   jresult = (void *)result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
15289   void * jresult ;
15290   Dali::BaseHandle *result = 0 ;
15291
15292   {
15293     try {
15294       result = (Dali::BaseHandle *)new Dali::BaseHandle();
15295     } catch (std::out_of_range& e) {
15296       {
15297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15298       };
15299     } catch (std::exception& e) {
15300       {
15301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (...) {
15304       {
15305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15306       };
15307     }
15308   }
15309   jresult = (void *)result;
15310   return jresult;
15311 }
15312
15313
15314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
15315   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15316
15317   arg1 = (Dali::BaseHandle *)jarg1;
15318   {
15319     try {
15320       delete arg1;
15321     } catch (std::out_of_range& e) {
15322       {
15323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15324       };
15325     } catch (std::exception& e) {
15326       {
15327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15328       };
15329     } catch (...) {
15330       {
15331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15332       };
15333     }
15334   }
15335 }
15336
15337
15338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
15339   void * jresult ;
15340   Dali::BaseHandle *arg1 = 0 ;
15341   Dali::BaseHandle *result = 0 ;
15342
15343   arg1 = (Dali::BaseHandle *)jarg1;
15344   if (!arg1) {
15345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
15346     return 0;
15347   }
15348   {
15349     try {
15350       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
15351     } catch (std::out_of_range& e) {
15352       {
15353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15354       };
15355     } catch (std::exception& e) {
15356       {
15357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15358       };
15359     } catch (...) {
15360       {
15361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15362       };
15363     }
15364   }
15365   jresult = (void *)result;
15366   return jresult;
15367 }
15368
15369
15370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
15371   void * jresult ;
15372   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15373   Dali::BaseHandle *arg2 = 0 ;
15374   Dali::BaseHandle *result = 0 ;
15375
15376   arg1 = (Dali::BaseHandle *)jarg1;
15377   arg2 = (Dali::BaseHandle *)jarg2;
15378   if (!arg2) {
15379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
15380     return 0;
15381   }
15382   {
15383     try {
15384       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
15385     } catch (std::out_of_range& e) {
15386       {
15387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15388       };
15389     } catch (std::exception& e) {
15390       {
15391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15392       };
15393     } catch (...) {
15394       {
15395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15396       };
15397     }
15398   }
15399   jresult = (void *)result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15405   unsigned int jresult ;
15406   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15407   std::string *arg2 = 0 ;
15408   Dali::Property::Map *arg3 = 0 ;
15409   bool result;
15410
15411   arg1 = (Dali::BaseHandle *)jarg1;
15412   if (!jarg2) {
15413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15414     return 0;
15415   }
15416   std::string arg2_str(jarg2);
15417   arg2 = &arg2_str;
15418   arg3 = (Dali::Property::Map *)jarg3;
15419   if (!arg3) {
15420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15421     return 0;
15422   }
15423   {
15424     try {
15425       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15426     } catch (std::out_of_range& e) {
15427       {
15428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15429       };
15430     } catch (std::exception& e) {
15431       {
15432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15433       };
15434     } catch (...) {
15435       {
15436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15437       };
15438     }
15439   }
15440   jresult = result;
15441
15442   //argout typemap for const std::string&
15443
15444   return jresult;
15445 }
15446
15447
15448 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
15449   char * jresult ;
15450   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15451   std::string *result = 0 ;
15452
15453   arg1 = (Dali::BaseHandle *)jarg1;
15454   {
15455     try {
15456       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
15457     } catch (std::out_of_range& e) {
15458       {
15459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15460       };
15461     } catch (std::exception& e) {
15462       {
15463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15464       };
15465     } catch (...) {
15466       {
15467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15468       };
15469     }
15470   }
15471   jresult = SWIG_csharp_string_callback(result->c_str());
15472   return jresult;
15473 }
15474
15475
15476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
15477   unsigned int jresult ;
15478   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15479   Dali::TypeInfo *arg2 = 0 ;
15480   bool result;
15481
15482   arg1 = (Dali::BaseHandle *)jarg1;
15483   arg2 = (Dali::TypeInfo *)jarg2;
15484   if (!arg2) {
15485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15486     return 0;
15487   }
15488   {
15489     try {
15490       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
15491     } catch (std::out_of_range& e) {
15492       {
15493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15494       };
15495     } catch (std::exception& e) {
15496       {
15497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15498       };
15499     } catch (...) {
15500       {
15501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15502       };
15503     }
15504   }
15505   jresult = result;
15506   return jresult;
15507 }
15508
15509
15510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
15511   void * jresult ;
15512   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15513   Dali::BaseObject *result = 0 ;
15514
15515   arg1 = (Dali::BaseHandle *)jarg1;
15516   {
15517     try {
15518       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
15519     } catch (std::out_of_range& e) {
15520       {
15521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15522       };
15523     } catch (std::exception& e) {
15524       {
15525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15526       };
15527     } catch (...) {
15528       {
15529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15530       };
15531     }
15532   }
15533   jresult = (void *)result;
15534   return jresult;
15535 }
15536
15537
15538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
15539   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15540
15541   arg1 = (Dali::BaseHandle *)jarg1;
15542   {
15543     try {
15544       (arg1)->Reset();
15545     } catch (std::out_of_range& e) {
15546       {
15547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15548       };
15549     } catch (std::exception& e) {
15550       {
15551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15552       };
15553     } catch (...) {
15554       {
15555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15556       };
15557     }
15558   }
15559 }
15560
15561
15562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
15563   unsigned int jresult ;
15564   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15565   Dali::BaseHandle *arg2 = 0 ;
15566   bool result;
15567
15568   arg1 = (Dali::BaseHandle *)jarg1;
15569   arg2 = (Dali::BaseHandle *)jarg2;
15570   if (!arg2) {
15571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
15572     return 0;
15573   }
15574   {
15575     try {
15576       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
15577     } catch (std::out_of_range& e) {
15578       {
15579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15580       };
15581     } catch (std::exception& e) {
15582       {
15583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15584       };
15585     } catch (...) {
15586       {
15587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15588       };
15589     }
15590   }
15591   jresult = result;
15592   return jresult;
15593 }
15594
15595
15596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
15597   unsigned int jresult ;
15598   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15599   Dali::BaseHandle *arg2 = 0 ;
15600   bool result;
15601
15602   arg1 = (Dali::BaseHandle *)jarg1;
15603   arg2 = (Dali::BaseHandle *)jarg2;
15604   if (!arg2) {
15605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
15606     return 0;
15607   }
15608   {
15609     try {
15610       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
15611     } catch (std::out_of_range& e) {
15612       {
15613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15614       };
15615     } catch (std::exception& e) {
15616       {
15617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15618       };
15619     } catch (...) {
15620       {
15621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15622       };
15623     }
15624   }
15625   jresult = result;
15626   return jresult;
15627 }
15628
15629
15630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
15631   void * jresult ;
15632   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15633   Dali::RefObject *result = 0 ;
15634
15635   arg1 = (Dali::BaseHandle *)jarg1;
15636   {
15637     try {
15638       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
15639     } catch (std::out_of_range& e) {
15640       {
15641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15642       };
15643     } catch (std::exception& e) {
15644       {
15645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15646       };
15647     } catch (...) {
15648       {
15649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15650       };
15651     }
15652   }
15653   jresult = (void *)result;
15654   return jresult;
15655 }
15656
15657
15658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsHandleEmpty(void * jarg1) {
15659   unsigned int jresult ;
15660   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
15661   bool result;
15662
15663   arg1 = (Dali::BaseHandle *)jarg1;
15664   {
15665     try {
15666       result = (bool)Dali_BaseHandle_IsHandleEmpty((Dali::BaseHandle const *)arg1);
15667     } catch (std::out_of_range& e) {
15668       {
15669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15670       };
15671     } catch (std::exception& e) {
15672       {
15673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15674       };
15675     } catch (...) {
15676       {
15677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15678       };
15679     }
15680   }
15681   jresult = result;
15682   return jresult;
15683 }
15684
15685
15686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
15687   unsigned int jresult ;
15688   Dali::BaseHandle *arg1 = 0 ;
15689   Dali::BaseHandle *arg2 = 0 ;
15690   bool result;
15691
15692   arg1 = (Dali::BaseHandle *)jarg1;
15693   if (!arg1) {
15694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
15695     return 0;
15696   }
15697   arg2 = (Dali::BaseHandle *)jarg2;
15698   if (!arg2) {
15699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
15700     return 0;
15701   }
15702   {
15703     try {
15704       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
15705     } catch (std::out_of_range& e) {
15706       {
15707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15708       };
15709     } catch (std::exception& e) {
15710       {
15711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15712       };
15713     } catch (...) {
15714       {
15715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15716       };
15717     }
15718   }
15719   jresult = result;
15720   return jresult;
15721 }
15722
15723
15724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
15725   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
15726
15727   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
15728   {
15729     try {
15730       delete arg1;
15731     } catch (std::out_of_range& e) {
15732       {
15733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15734       };
15735     } catch (std::exception& e) {
15736       {
15737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15738       };
15739     } catch (...) {
15740       {
15741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15742       };
15743     }
15744   }
15745 }
15746
15747
15748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
15749   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
15750   SlotObserver *arg2 = (SlotObserver *) 0 ;
15751   CallbackBase *arg3 = (CallbackBase *) 0 ;
15752
15753   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
15754   arg2 = (SlotObserver *)jarg2;
15755   arg3 = (CallbackBase *)jarg3;
15756   {
15757     try {
15758       (arg1)->SignalConnected(arg2,arg3);
15759     } catch (std::out_of_range& e) {
15760       {
15761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15762       };
15763     } catch (std::exception& e) {
15764       {
15765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15766       };
15767     } catch (...) {
15768       {
15769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15770       };
15771     }
15772   }
15773 }
15774
15775
15776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
15777   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
15778
15779   arg1 = (Dali::SignalObserver *)jarg1;
15780   {
15781     try {
15782       delete arg1;
15783     } catch (std::out_of_range& e) {
15784       {
15785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15786       };
15787     } catch (std::exception& e) {
15788       {
15789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15790       };
15791     } catch (...) {
15792       {
15793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15794       };
15795     }
15796   }
15797 }
15798
15799
15800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
15801   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
15802   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
15803   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
15804
15805   arg1 = (Dali::SignalObserver *)jarg1;
15806   arg2 = (Dali::SlotObserver *)jarg2;
15807   arg3 = (Dali::CallbackBase *)jarg3;
15808   {
15809     try {
15810       (arg1)->SignalDisconnected(arg2,arg3);
15811     } catch (std::out_of_range& e) {
15812       {
15813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15814       };
15815     } catch (std::exception& e) {
15816       {
15817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15818       };
15819     } catch (...) {
15820       {
15821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15822       };
15823     }
15824   }
15825 }
15826
15827
15828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
15829   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
15830
15831   arg1 = (Dali::SlotObserver *)jarg1;
15832   {
15833     try {
15834       delete arg1;
15835     } catch (std::out_of_range& e) {
15836       {
15837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15838       };
15839     } catch (std::exception& e) {
15840       {
15841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15842       };
15843     } catch (...) {
15844       {
15845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15846       };
15847     }
15848   }
15849 }
15850
15851
15852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
15853   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
15854   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
15855
15856   arg1 = (Dali::SlotObserver *)jarg1;
15857   arg2 = (Dali::CallbackBase *)jarg2;
15858   {
15859     try {
15860       (arg1)->SlotDisconnected(arg2);
15861     } catch (std::out_of_range& e) {
15862       {
15863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15864       };
15865     } catch (std::exception& e) {
15866       {
15867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15868       };
15869     } catch (...) {
15870       {
15871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15872       };
15873     }
15874   }
15875 }
15876
15877
15878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
15879   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
15880
15881   arg1 = (Dali::ConnectionTracker *)jarg1;
15882   {
15883     try {
15884       delete arg1;
15885     } catch (std::out_of_range& e) {
15886       {
15887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15888       };
15889     } catch (std::exception& e) {
15890       {
15891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15892       };
15893     } catch (...) {
15894       {
15895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15896       };
15897     }
15898   }
15899 }
15900
15901
15902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
15903   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
15904
15905   arg1 = (Dali::ConnectionTracker *)jarg1;
15906   {
15907     try {
15908       (arg1)->DisconnectAll();
15909     } catch (std::out_of_range& e) {
15910       {
15911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15912       };
15913     } catch (std::exception& e) {
15914       {
15915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15916       };
15917     } catch (...) {
15918       {
15919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15920       };
15921     }
15922   }
15923 }
15924
15925
15926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
15927   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
15928   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
15929   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
15930
15931   arg1 = (Dali::ConnectionTracker *)jarg1;
15932   arg2 = (Dali::SlotObserver *)jarg2;
15933   arg3 = (Dali::CallbackBase *)jarg3;
15934   {
15935     try {
15936       (arg1)->SignalConnected(arg2,arg3);
15937     } catch (std::out_of_range& e) {
15938       {
15939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15940       };
15941     } catch (std::exception& e) {
15942       {
15943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15944       };
15945     } catch (...) {
15946       {
15947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15948       };
15949     }
15950   }
15951 }
15952
15953
15954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
15955   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
15956   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
15957   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
15958
15959   arg1 = (Dali::ConnectionTracker *)jarg1;
15960   arg2 = (Dali::SlotObserver *)jarg2;
15961   arg3 = (Dali::CallbackBase *)jarg3;
15962   {
15963     try {
15964       (arg1)->SignalDisconnected(arg2,arg3);
15965     } catch (std::out_of_range& e) {
15966       {
15967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15968       };
15969     } catch (std::exception& e) {
15970       {
15971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15972       };
15973     } catch (...) {
15974       {
15975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15976       };
15977     }
15978   }
15979 }
15980
15981
15982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
15983   unsigned long jresult ;
15984   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
15985   std::size_t result;
15986
15987   arg1 = (Dali::ConnectionTracker *)jarg1;
15988   {
15989     try {
15990       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
15991     } catch (std::out_of_range& e) {
15992       {
15993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15994       };
15995     } catch (std::exception& e) {
15996       {
15997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15998       };
15999     } catch (...) {
16000       {
16001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16002       };
16003     }
16004   }
16005   jresult = (unsigned long)result;
16006   return jresult;
16007 }
16008
16009
16010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16011   void * jresult ;
16012   Dali::ObjectRegistry *result = 0 ;
16013
16014   {
16015     try {
16016       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16017     } catch (std::out_of_range& e) {
16018       {
16019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16020       };
16021     } catch (std::exception& e) {
16022       {
16023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16024       };
16025     } catch (...) {
16026       {
16027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16028       };
16029     }
16030   }
16031   jresult = (void *)result;
16032   return jresult;
16033 }
16034
16035
16036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16037   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16038
16039   arg1 = (Dali::ObjectRegistry *)jarg1;
16040   {
16041     try {
16042       delete arg1;
16043     } catch (std::out_of_range& e) {
16044       {
16045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16046       };
16047     } catch (std::exception& e) {
16048       {
16049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16050       };
16051     } catch (...) {
16052       {
16053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16054       };
16055     }
16056   }
16057 }
16058
16059
16060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16061   void * jresult ;
16062   Dali::ObjectRegistry *arg1 = 0 ;
16063   Dali::ObjectRegistry *result = 0 ;
16064
16065   arg1 = (Dali::ObjectRegistry *)jarg1;
16066   if (!arg1) {
16067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16068     return 0;
16069   }
16070   {
16071     try {
16072       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16073     } catch (std::out_of_range& e) {
16074       {
16075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16076       };
16077     } catch (std::exception& e) {
16078       {
16079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16080       };
16081     } catch (...) {
16082       {
16083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16084       };
16085     }
16086   }
16087   jresult = (void *)result;
16088   return jresult;
16089 }
16090
16091
16092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16093   void * jresult ;
16094   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16095   Dali::ObjectRegistry *arg2 = 0 ;
16096   Dali::ObjectRegistry *result = 0 ;
16097
16098   arg1 = (Dali::ObjectRegistry *)jarg1;
16099   arg2 = (Dali::ObjectRegistry *)jarg2;
16100   if (!arg2) {
16101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16102     return 0;
16103   }
16104   {
16105     try {
16106       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16107     } catch (std::out_of_range& e) {
16108       {
16109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16110       };
16111     } catch (std::exception& e) {
16112       {
16113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16114       };
16115     } catch (...) {
16116       {
16117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16118       };
16119     }
16120   }
16121   jresult = (void *)result;
16122   return jresult;
16123 }
16124
16125
16126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16127   void * jresult ;
16128   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16129   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16130
16131   arg1 = (Dali::ObjectRegistry *)jarg1;
16132   {
16133     try {
16134       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16135     } catch (std::out_of_range& e) {
16136       {
16137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16138       };
16139     } catch (std::exception& e) {
16140       {
16141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16142       };
16143     } catch (...) {
16144       {
16145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16146       };
16147     }
16148   }
16149   jresult = (void *)result;
16150   return jresult;
16151 }
16152
16153
16154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16155   void * jresult ;
16156   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16157   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16158
16159   arg1 = (Dali::ObjectRegistry *)jarg1;
16160   {
16161     try {
16162       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16163     } catch (std::out_of_range& e) {
16164       {
16165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16166       };
16167     } catch (std::exception& e) {
16168       {
16169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16170       };
16171     } catch (...) {
16172       {
16173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16174       };
16175     }
16176   }
16177   jresult = (void *)result;
16178   return jresult;
16179 }
16180
16181
16182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
16183   void * jresult ;
16184   Dali::PropertyCondition *result = 0 ;
16185
16186   {
16187     try {
16188       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
16189     } catch (std::out_of_range& e) {
16190       {
16191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16192       };
16193     } catch (std::exception& e) {
16194       {
16195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16196       };
16197     } catch (...) {
16198       {
16199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16200       };
16201     }
16202   }
16203   jresult = (void *)result;
16204   return jresult;
16205 }
16206
16207
16208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
16209   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
16210
16211   arg1 = (Dali::PropertyCondition *)jarg1;
16212   {
16213     try {
16214       delete arg1;
16215     } catch (std::out_of_range& e) {
16216       {
16217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16218       };
16219     } catch (std::exception& e) {
16220       {
16221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16222       };
16223     } catch (...) {
16224       {
16225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16226       };
16227     }
16228   }
16229 }
16230
16231
16232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
16233   void * jresult ;
16234   Dali::PropertyCondition *arg1 = 0 ;
16235   Dali::PropertyCondition *result = 0 ;
16236
16237   arg1 = (Dali::PropertyCondition *)jarg1;
16238   if (!arg1) {
16239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
16240     return 0;
16241   }
16242   {
16243     try {
16244       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
16245     } catch (std::out_of_range& e) {
16246       {
16247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16248       };
16249     } catch (std::exception& e) {
16250       {
16251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16252       };
16253     } catch (...) {
16254       {
16255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16256       };
16257     }
16258   }
16259   jresult = (void *)result;
16260   return jresult;
16261 }
16262
16263
16264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
16265   void * jresult ;
16266   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
16267   Dali::PropertyCondition *arg2 = 0 ;
16268   Dali::PropertyCondition *result = 0 ;
16269
16270   arg1 = (Dali::PropertyCondition *)jarg1;
16271   arg2 = (Dali::PropertyCondition *)jarg2;
16272   if (!arg2) {
16273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
16274     return 0;
16275   }
16276   {
16277     try {
16278       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
16279     } catch (std::out_of_range& e) {
16280       {
16281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16282       };
16283     } catch (std::exception& e) {
16284       {
16285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16286       };
16287     } catch (...) {
16288       {
16289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16290       };
16291     }
16292   }
16293   jresult = (void *)result;
16294   return jresult;
16295 }
16296
16297
16298 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
16299   unsigned long jresult ;
16300   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
16301   std::size_t result;
16302
16303   arg1 = (Dali::PropertyCondition *)jarg1;
16304   {
16305     try {
16306       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
16307     } catch (std::out_of_range& e) {
16308       {
16309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16310       };
16311     } catch (std::exception& e) {
16312       {
16313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16314       };
16315     } catch (...) {
16316       {
16317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16318       };
16319     }
16320   }
16321   jresult = (unsigned long)result;
16322   return jresult;
16323 }
16324
16325
16326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
16327   float jresult ;
16328   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
16329   std::size_t arg2 ;
16330   float result;
16331
16332   arg1 = (Dali::PropertyCondition *)jarg1;
16333   arg2 = (std::size_t)jarg2;
16334   {
16335     try {
16336       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
16337     } catch (std::out_of_range& e) {
16338       {
16339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16340       };
16341     } catch (std::exception& e) {
16342       {
16343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16344       };
16345     } catch (...) {
16346       {
16347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16348       };
16349     }
16350   }
16351   jresult = result;
16352   return jresult;
16353 }
16354
16355
16356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
16357   void * jresult ;
16358   float arg1 ;
16359   Dali::PropertyCondition result;
16360
16361   arg1 = (float)jarg1;
16362   {
16363     try {
16364       result = Dali::LessThanCondition(arg1);
16365     } catch (std::out_of_range& e) {
16366       {
16367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16368       };
16369     } catch (std::exception& e) {
16370       {
16371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16372       };
16373     } catch (...) {
16374       {
16375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16376       };
16377     }
16378   }
16379   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
16380   return jresult;
16381 }
16382
16383
16384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
16385   void * jresult ;
16386   float arg1 ;
16387   Dali::PropertyCondition result;
16388
16389   arg1 = (float)jarg1;
16390   {
16391     try {
16392       result = Dali::GreaterThanCondition(arg1);
16393     } catch (std::out_of_range& e) {
16394       {
16395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16396       };
16397     } catch (std::exception& e) {
16398       {
16399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16400       };
16401     } catch (...) {
16402       {
16403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16404       };
16405     }
16406   }
16407   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
16408   return jresult;
16409 }
16410
16411
16412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
16413   void * jresult ;
16414   float arg1 ;
16415   float arg2 ;
16416   Dali::PropertyCondition result;
16417
16418   arg1 = (float)jarg1;
16419   arg2 = (float)jarg2;
16420   {
16421     try {
16422       result = Dali::InsideCondition(arg1,arg2);
16423     } catch (std::out_of_range& e) {
16424       {
16425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16426       };
16427     } catch (std::exception& e) {
16428       {
16429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16430       };
16431     } catch (...) {
16432       {
16433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16434       };
16435     }
16436   }
16437   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
16438   return jresult;
16439 }
16440
16441
16442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
16443   void * jresult ;
16444   float arg1 ;
16445   float arg2 ;
16446   Dali::PropertyCondition result;
16447
16448   arg1 = (float)jarg1;
16449   arg2 = (float)jarg2;
16450   {
16451     try {
16452       result = Dali::OutsideCondition(arg1,arg2);
16453     } catch (std::out_of_range& e) {
16454       {
16455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16456       };
16457     } catch (std::exception& e) {
16458       {
16459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16460       };
16461     } catch (...) {
16462       {
16463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16464       };
16465     }
16466   }
16467   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
16468   return jresult;
16469 }
16470
16471
16472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
16473   void * jresult ;
16474   float arg1 ;
16475   float arg2 ;
16476   Dali::PropertyCondition result;
16477
16478   arg1 = (float)jarg1;
16479   arg2 = (float)jarg2;
16480   {
16481     try {
16482       result = Dali::StepCondition(arg1,arg2);
16483     } catch (std::out_of_range& e) {
16484       {
16485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16486       };
16487     } catch (std::exception& e) {
16488       {
16489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16490       };
16491     } catch (...) {
16492       {
16493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16494       };
16495     }
16496   }
16497   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
16498   return jresult;
16499 }
16500
16501
16502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
16503   void * jresult ;
16504   float arg1 ;
16505   Dali::PropertyCondition result;
16506
16507   arg1 = (float)jarg1;
16508   {
16509     try {
16510       result = Dali::StepCondition(arg1);
16511     } catch (std::out_of_range& e) {
16512       {
16513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16514       };
16515     } catch (std::exception& e) {
16516       {
16517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16518       };
16519     } catch (...) {
16520       {
16521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16522       };
16523     }
16524   }
16525   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
16526   return jresult;
16527 }
16528
16529
16530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
16531   void * jresult ;
16532   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
16533   Dali::PropertyCondition result;
16534
16535   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
16536   if (!arg1) {
16537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
16538     return 0;
16539   }
16540   {
16541     try {
16542       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
16543     } catch (std::out_of_range& e) {
16544       {
16545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16546       };
16547     } catch (std::exception& e) {
16548       {
16549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16550       };
16551     } catch (...) {
16552       {
16553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16554       };
16555     }
16556   }
16557   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
16558   return jresult;
16559 }
16560
16561
16562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
16563   void * jresult ;
16564   Dali::PropertyNotification *result = 0 ;
16565
16566   {
16567     try {
16568       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
16569     } catch (std::out_of_range& e) {
16570       {
16571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16572       };
16573     } catch (std::exception& e) {
16574       {
16575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16576       };
16577     } catch (...) {
16578       {
16579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16580       };
16581     }
16582   }
16583   jresult = (void *)result;
16584   return jresult;
16585 }
16586
16587
16588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
16589   void * jresult ;
16590   Dali::BaseHandle arg1 ;
16591   Dali::BaseHandle *argp1 ;
16592   Dali::PropertyNotification result;
16593
16594   argp1 = (Dali::BaseHandle *)jarg1;
16595   if (!argp1) {
16596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16597     return 0;
16598   }
16599   arg1 = *argp1;
16600   {
16601     try {
16602       result = Dali::PropertyNotification::DownCast(arg1);
16603     } catch (std::out_of_range& e) {
16604       {
16605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16606       };
16607     } catch (std::exception& e) {
16608       {
16609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16610       };
16611     } catch (...) {
16612       {
16613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16614       };
16615     }
16616   }
16617   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
16618   return jresult;
16619 }
16620
16621
16622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
16623   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
16624
16625   arg1 = (Dali::PropertyNotification *)jarg1;
16626   {
16627     try {
16628       delete arg1;
16629     } catch (std::out_of_range& e) {
16630       {
16631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16632       };
16633     } catch (std::exception& e) {
16634       {
16635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16636       };
16637     } catch (...) {
16638       {
16639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16640       };
16641     }
16642   }
16643 }
16644
16645
16646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
16647   void * jresult ;
16648   Dali::PropertyNotification *arg1 = 0 ;
16649   Dali::PropertyNotification *result = 0 ;
16650
16651   arg1 = (Dali::PropertyNotification *)jarg1;
16652   if (!arg1) {
16653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
16654     return 0;
16655   }
16656   {
16657     try {
16658       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
16659     } catch (std::out_of_range& e) {
16660       {
16661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16662       };
16663     } catch (std::exception& e) {
16664       {
16665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16666       };
16667     } catch (...) {
16668       {
16669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16670       };
16671     }
16672   }
16673   jresult = (void *)result;
16674   return jresult;
16675 }
16676
16677
16678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
16679   void * jresult ;
16680   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
16681   Dali::PropertyNotification *arg2 = 0 ;
16682   Dali::PropertyNotification *result = 0 ;
16683
16684   arg1 = (Dali::PropertyNotification *)jarg1;
16685   arg2 = (Dali::PropertyNotification *)jarg2;
16686   if (!arg2) {
16687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
16688     return 0;
16689   }
16690   {
16691     try {
16692       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
16693     } catch (std::out_of_range& e) {
16694       {
16695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16696       };
16697     } catch (std::exception& e) {
16698       {
16699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16700       };
16701     } catch (...) {
16702       {
16703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16704       };
16705     }
16706   }
16707   jresult = (void *)result;
16708   return jresult;
16709 }
16710
16711
16712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
16713   void * jresult ;
16714   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
16715   Dali::PropertyCondition result;
16716
16717   arg1 = (Dali::PropertyNotification *)jarg1;
16718   {
16719     try {
16720       result = (arg1)->GetCondition();
16721     } catch (std::out_of_range& e) {
16722       {
16723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16724       };
16725     } catch (std::exception& e) {
16726       {
16727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16728       };
16729     } catch (...) {
16730       {
16731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16732       };
16733     }
16734   }
16735   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
16736   return jresult;
16737 }
16738
16739
16740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
16741   void * jresult ;
16742   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
16743   Dali::Handle result;
16744
16745   arg1 = (Dali::PropertyNotification *)jarg1;
16746   {
16747     try {
16748       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
16749     } catch (std::out_of_range& e) {
16750       {
16751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16752       };
16753     } catch (std::exception& e) {
16754       {
16755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16756       };
16757     } catch (...) {
16758       {
16759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16760       };
16761     }
16762   }
16763   jresult = new Dali::Handle((const Dali::Handle &)result);
16764   return jresult;
16765 }
16766
16767
16768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
16769   int jresult ;
16770   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
16771   Dali::Property::Index result;
16772
16773   arg1 = (Dali::PropertyNotification *)jarg1;
16774   {
16775     try {
16776       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
16777     } catch (std::out_of_range& e) {
16778       {
16779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16780       };
16781     } catch (std::exception& e) {
16782       {
16783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16784       };
16785     } catch (...) {
16786       {
16787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16788       };
16789     }
16790   }
16791   jresult = result;
16792   return jresult;
16793 }
16794
16795
16796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
16797   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
16798   Dali::PropertyNotification::NotifyMode arg2 ;
16799
16800   arg1 = (Dali::PropertyNotification *)jarg1;
16801   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
16802   {
16803     try {
16804       (arg1)->SetNotifyMode(arg2);
16805     } catch (std::out_of_range& e) {
16806       {
16807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16808       };
16809     } catch (std::exception& e) {
16810       {
16811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16812       };
16813     } catch (...) {
16814       {
16815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16816       };
16817     }
16818   }
16819 }
16820
16821
16822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
16823   int jresult ;
16824   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
16825   Dali::PropertyNotification::NotifyMode result;
16826
16827   arg1 = (Dali::PropertyNotification *)jarg1;
16828   {
16829     try {
16830       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
16831     } catch (std::out_of_range& e) {
16832       {
16833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16834       };
16835     } catch (std::exception& e) {
16836       {
16837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16838       };
16839     } catch (...) {
16840       {
16841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16842       };
16843     }
16844   }
16845   jresult = (int)result;
16846   return jresult;
16847 }
16848
16849
16850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
16851   unsigned int jresult ;
16852   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
16853   bool result;
16854
16855   arg1 = (Dali::PropertyNotification *)jarg1;
16856   {
16857     try {
16858       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
16859     } catch (std::out_of_range& e) {
16860       {
16861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16862       };
16863     } catch (std::exception& e) {
16864       {
16865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16866       };
16867     } catch (...) {
16868       {
16869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16870       };
16871     }
16872   }
16873   jresult = result;
16874   return jresult;
16875 }
16876
16877
16878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
16879   void * jresult ;
16880   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
16881   Dali::PropertyNotifySignalType *result = 0 ;
16882
16883   arg1 = (Dali::PropertyNotification *)jarg1;
16884   {
16885     try {
16886       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
16887     } catch (std::out_of_range& e) {
16888       {
16889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16890       };
16891     } catch (std::exception& e) {
16892       {
16893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16894       };
16895     } catch (...) {
16896       {
16897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16898       };
16899     }
16900   }
16901   jresult = (void *)result;
16902   return jresult;
16903 }
16904
16905
16906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
16907   void * jresult ;
16908   Dali::Handle *result = 0 ;
16909
16910   {
16911     try {
16912       result = (Dali::Handle *)new Dali::Handle();
16913     } catch (std::out_of_range& e) {
16914       {
16915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16916       };
16917     } catch (std::exception& e) {
16918       {
16919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16920       };
16921     } catch (...) {
16922       {
16923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16924       };
16925     }
16926   }
16927   jresult = (void *)result;
16928   return jresult;
16929 }
16930
16931
16932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
16933   void * jresult ;
16934   Dali::Handle result;
16935
16936   {
16937     try {
16938       result = Dali::Handle::New();
16939     } catch (std::out_of_range& e) {
16940       {
16941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (std::exception& e) {
16944       {
16945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953   jresult = new Dali::Handle((const Dali::Handle &)result);
16954   return jresult;
16955 }
16956
16957
16958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
16959   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
16960
16961   arg1 = (Dali::Handle *)jarg1;
16962   {
16963     try {
16964       delete arg1;
16965     } catch (std::out_of_range& e) {
16966       {
16967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16968       };
16969     } catch (std::exception& e) {
16970       {
16971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16972       };
16973     } catch (...) {
16974       {
16975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16976       };
16977     }
16978   }
16979 }
16980
16981
16982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
16983   void * jresult ;
16984   Dali::Handle *arg1 = 0 ;
16985   Dali::Handle *result = 0 ;
16986
16987   arg1 = (Dali::Handle *)jarg1;
16988   if (!arg1) {
16989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
16990     return 0;
16991   }
16992   {
16993     try {
16994       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
16995     } catch (std::out_of_range& e) {
16996       {
16997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16998       };
16999     } catch (std::exception& e) {
17000       {
17001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17002       };
17003     } catch (...) {
17004       {
17005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17006       };
17007     }
17008   }
17009   jresult = (void *)result;
17010   return jresult;
17011 }
17012
17013
17014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17015   void * jresult ;
17016   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17017   Dali::Handle *arg2 = 0 ;
17018   Dali::Handle *result = 0 ;
17019
17020   arg1 = (Dali::Handle *)jarg1;
17021   arg2 = (Dali::Handle *)jarg2;
17022   if (!arg2) {
17023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17024     return 0;
17025   }
17026   {
17027     try {
17028       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17029     } catch (std::out_of_range& e) {
17030       {
17031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17032       };
17033     } catch (std::exception& e) {
17034       {
17035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17036       };
17037     } catch (...) {
17038       {
17039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17040       };
17041     }
17042   }
17043   jresult = (void *)result;
17044   return jresult;
17045 }
17046
17047
17048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17049   void * jresult ;
17050   Dali::BaseHandle arg1 ;
17051   Dali::BaseHandle *argp1 ;
17052   Dali::Handle result;
17053
17054   argp1 = (Dali::BaseHandle *)jarg1;
17055   if (!argp1) {
17056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17057     return 0;
17058   }
17059   arg1 = *argp1;
17060   {
17061     try {
17062       result = Dali::Handle::DownCast(arg1);
17063     } catch (std::out_of_range& e) {
17064       {
17065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17066       };
17067     } catch (std::exception& e) {
17068       {
17069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (...) {
17072       {
17073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17074       };
17075     }
17076   }
17077   jresult = new Dali::Handle((const Dali::Handle &)result);
17078   return jresult;
17079 }
17080
17081
17082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17083   unsigned int jresult ;
17084   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17085   Dali::Handle::Capability arg2 ;
17086   bool result;
17087
17088   arg1 = (Dali::Handle *)jarg1;
17089   arg2 = (Dali::Handle::Capability)jarg2;
17090   {
17091     try {
17092       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17093     } catch (std::out_of_range& e) {
17094       {
17095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17096       };
17097     } catch (std::exception& e) {
17098       {
17099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17100       };
17101     } catch (...) {
17102       {
17103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17104       };
17105     }
17106   }
17107   jresult = result;
17108   return jresult;
17109 }
17110
17111
17112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17113   unsigned int jresult ;
17114   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17115   unsigned int result;
17116
17117   arg1 = (Dali::Handle *)jarg1;
17118   {
17119     try {
17120       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17121     } catch (std::out_of_range& e) {
17122       {
17123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17124       };
17125     } catch (std::exception& e) {
17126       {
17127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (...) {
17130       {
17131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17132       };
17133     }
17134   }
17135   jresult = result;
17136   return jresult;
17137 }
17138
17139
17140 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17141   char * jresult ;
17142   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17143   Dali::Property::Index arg2 ;
17144   std::string result;
17145
17146   arg1 = (Dali::Handle *)jarg1;
17147   arg2 = (Dali::Property::Index)jarg2;
17148   {
17149     try {
17150       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17151     } catch (std::out_of_range& e) {
17152       {
17153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17154       };
17155     } catch (std::exception& e) {
17156       {
17157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17158       };
17159     } catch (...) {
17160       {
17161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17162       };
17163     }
17164   }
17165   jresult = SWIG_csharp_string_callback((&result)->c_str());
17166   return jresult;
17167 }
17168
17169
17170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex__SWIG_0(void * jarg1, char * jarg2) {
17171   int jresult ;
17172   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17173   std::string *arg2 = 0 ;
17174   Dali::Property::Index result;
17175
17176   arg1 = (Dali::Handle *)jarg1;
17177   if (!jarg2) {
17178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17179     return 0;
17180   }
17181   std::string arg2_str(jarg2);
17182   arg2 = &arg2_str;
17183   {
17184     try {
17185       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
17186     } catch (std::out_of_range& e) {
17187       {
17188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17189       };
17190     } catch (std::exception& e) {
17191       {
17192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17193       };
17194     } catch (...) {
17195       {
17196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17197       };
17198     }
17199   }
17200   jresult = result;
17201
17202   //argout typemap for const std::string&
17203
17204   return jresult;
17205 }
17206
17207
17208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex__SWIG_1(void * jarg1, int jarg2) {
17209   int jresult ;
17210   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17211   Dali::Property::Index arg2 ;
17212   Dali::Property::Index result;
17213
17214   arg1 = (Dali::Handle *)jarg1;
17215   arg2 = (Dali::Property::Index)jarg2;
17216   {
17217     try {
17218       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex(arg2);
17219     } catch (std::out_of_range& e) {
17220       {
17221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17222       };
17223     } catch (std::exception& e) {
17224       {
17225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17226       };
17227     } catch (...) {
17228       {
17229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17230       };
17231     }
17232   }
17233   jresult = result;
17234   return jresult;
17235 }
17236
17237
17238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex__SWIG_2(void * jarg1, void * jarg2) {
17239   int jresult ;
17240   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17241   SwigValueWrapper< Dali::Property::Key > arg2 ;
17242   Dali::Property::Key *argp2 ;
17243   Dali::Property::Index result;
17244
17245   arg1 = (Dali::Handle *)jarg1;
17246   argp2 = (Dali::Property::Key *)jarg2;
17247   if (!argp2) {
17248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Key", 0);
17249     return 0;
17250   }
17251   arg2 = *argp2;
17252   {
17253     try {
17254       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex(arg2);
17255     } catch (std::out_of_range& e) {
17256       {
17257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17258       };
17259     } catch (std::exception& e) {
17260       {
17261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17262       };
17263     } catch (...) {
17264       {
17265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17266       };
17267     }
17268   }
17269   jresult = result;
17270   return jresult;
17271 }
17272
17273
17274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
17275   unsigned int jresult ;
17276   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17277   Dali::Property::Index arg2 ;
17278   bool result;
17279
17280   arg1 = (Dali::Handle *)jarg1;
17281   arg2 = (Dali::Property::Index)jarg2;
17282   {
17283     try {
17284       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
17285     } catch (std::out_of_range& e) {
17286       {
17287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17288       };
17289     } catch (std::exception& e) {
17290       {
17291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17292       };
17293     } catch (...) {
17294       {
17295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17296       };
17297     }
17298   }
17299   jresult = result;
17300   return jresult;
17301 }
17302
17303
17304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
17305   unsigned int jresult ;
17306   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17307   Dali::Property::Index arg2 ;
17308   bool result;
17309
17310   arg1 = (Dali::Handle *)jarg1;
17311   arg2 = (Dali::Property::Index)jarg2;
17312   {
17313     try {
17314       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
17315     } catch (std::out_of_range& e) {
17316       {
17317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17318       };
17319     } catch (std::exception& e) {
17320       {
17321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17322       };
17323     } catch (...) {
17324       {
17325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17326       };
17327     }
17328   }
17329   jresult = result;
17330   return jresult;
17331 }
17332
17333
17334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
17335   unsigned int jresult ;
17336   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17337   Dali::Property::Index arg2 ;
17338   bool result;
17339
17340   arg1 = (Dali::Handle *)jarg1;
17341   arg2 = (Dali::Property::Index)jarg2;
17342   {
17343     try {
17344       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
17345     } catch (std::out_of_range& e) {
17346       {
17347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17348       };
17349     } catch (std::exception& e) {
17350       {
17351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17352       };
17353     } catch (...) {
17354       {
17355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17356       };
17357     }
17358   }
17359   jresult = result;
17360   return jresult;
17361 }
17362
17363
17364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
17365   int jresult ;
17366   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17367   Dali::Property::Index arg2 ;
17368   Dali::Property::Type result;
17369
17370   arg1 = (Dali::Handle *)jarg1;
17371   arg2 = (Dali::Property::Index)jarg2;
17372   {
17373     try {
17374       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
17375     } catch (std::out_of_range& e) {
17376       {
17377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17378       };
17379     } catch (std::exception& e) {
17380       {
17381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17382       };
17383     } catch (...) {
17384       {
17385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17386       };
17387     }
17388   }
17389   jresult = (int)result;
17390   return jresult;
17391 }
17392
17393
17394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
17395   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17396   Dali::Property::Index arg2 ;
17397   Dali::Property::Value *arg3 = 0 ;
17398
17399   arg1 = (Dali::Handle *)jarg1;
17400   arg2 = (Dali::Property::Index)jarg2;
17401   arg3 = (Dali::Property::Value *)jarg3;
17402   if (!arg3) {
17403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17404     return ;
17405   }
17406   {
17407     try {
17408       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
17409     } catch (std::out_of_range& e) {
17410       {
17411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17412       };
17413     } catch (std::exception& e) {
17414       {
17415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17416       };
17417     } catch (...) {
17418       {
17419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17420       };
17421     }
17422   }
17423 }
17424
17425
17426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
17427   int jresult ;
17428   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17429   std::string *arg2 = 0 ;
17430   Dali::Property::Value *arg3 = 0 ;
17431   Dali::Property::Index result;
17432
17433   arg1 = (Dali::Handle *)jarg1;
17434   if (!jarg2) {
17435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17436     return 0;
17437   }
17438   std::string arg2_str(jarg2);
17439   arg2 = &arg2_str;
17440   arg3 = (Dali::Property::Value *)jarg3;
17441   if (!arg3) {
17442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17443     return 0;
17444   }
17445   {
17446     try {
17447       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
17448     } catch (std::out_of_range& e) {
17449       {
17450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17451       };
17452     } catch (std::exception& e) {
17453       {
17454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17455       };
17456     } catch (...) {
17457       {
17458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17459       };
17460     }
17461   }
17462   jresult = result;
17463
17464   //argout typemap for const std::string&
17465
17466   return jresult;
17467 }
17468
17469
17470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, int jarg2, char * jarg3, void * jarg4) {
17471   int jresult ;
17472   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17473   Dali::Property::Index arg2 ;
17474   std::string *arg3 = 0 ;
17475   Dali::Property::Value *arg4 = 0 ;
17476   Dali::Property::Index result;
17477
17478   arg1 = (Dali::Handle *)jarg1;
17479   arg2 = (Dali::Property::Index)jarg2;
17480   if (!jarg3) {
17481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17482     return 0;
17483   }
17484   std::string arg3_str(jarg3);
17485   arg3 = &arg3_str;
17486   arg4 = (Dali::Property::Value *)jarg4;
17487   if (!arg4) {
17488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17489     return 0;
17490   }
17491   {
17492     try {
17493       result = (Dali::Property::Index)(arg1)->RegisterProperty(arg2,(std::string const &)*arg3,(Dali::Property::Value const &)*arg4);
17494     } catch (std::out_of_range& e) {
17495       {
17496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17497       };
17498     } catch (std::exception& e) {
17499       {
17500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17501       };
17502     } catch (...) {
17503       {
17504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17505       };
17506     }
17507   }
17508   jresult = result;
17509
17510   //argout typemap for const std::string&
17511
17512   return jresult;
17513 }
17514
17515
17516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
17517   int jresult ;
17518   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17519   std::string *arg2 = 0 ;
17520   Dali::Property::Value *arg3 = 0 ;
17521   Dali::Property::AccessMode arg4 ;
17522   Dali::Property::Index result;
17523
17524   arg1 = (Dali::Handle *)jarg1;
17525   if (!jarg2) {
17526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17527     return 0;
17528   }
17529   std::string arg2_str(jarg2);
17530   arg2 = &arg2_str;
17531   arg3 = (Dali::Property::Value *)jarg3;
17532   if (!arg3) {
17533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17534     return 0;
17535   }
17536   arg4 = (Dali::Property::AccessMode)jarg4;
17537   {
17538     try {
17539       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
17540     } catch (std::out_of_range& e) {
17541       {
17542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17543       };
17544     } catch (std::exception& e) {
17545       {
17546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17547       };
17548     } catch (...) {
17549       {
17550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17551       };
17552     }
17553   }
17554   jresult = result;
17555
17556   //argout typemap for const std::string&
17557
17558   return jresult;
17559 }
17560
17561
17562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
17563   void * jresult ;
17564   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17565   Dali::Property::Index arg2 ;
17566   Dali::Property::Value result;
17567
17568   arg1 = (Dali::Handle *)jarg1;
17569   arg2 = (Dali::Property::Index)jarg2;
17570   {
17571     try {
17572       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
17573     } catch (std::out_of_range& e) {
17574       {
17575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17576       };
17577     } catch (std::exception& e) {
17578       {
17579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17580       };
17581     } catch (...) {
17582       {
17583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17584       };
17585     }
17586   }
17587   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
17588   return jresult;
17589 }
17590
17591
17592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
17593   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17594   Dali::Property::IndexContainer *arg2 = 0 ;
17595
17596   arg1 = (Dali::Handle *)jarg1;
17597   arg2 = (Dali::Property::IndexContainer *)jarg2;
17598   if (!arg2) {
17599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
17600     return ;
17601   }
17602   {
17603     try {
17604       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
17605     } catch (std::out_of_range& e) {
17606       {
17607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17608       };
17609     } catch (std::exception& e) {
17610       {
17611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17612       };
17613     } catch (...) {
17614       {
17615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17616       };
17617     }
17618   }
17619 }
17620
17621
17622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
17623   void * jresult ;
17624   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17625   Dali::Property::Index arg2 ;
17626   Dali::PropertyCondition *arg3 = 0 ;
17627   Dali::PropertyNotification result;
17628
17629   arg1 = (Dali::Handle *)jarg1;
17630   arg2 = (Dali::Property::Index)jarg2;
17631   arg3 = (Dali::PropertyCondition *)jarg3;
17632   if (!arg3) {
17633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17634     return 0;
17635   }
17636   {
17637     try {
17638       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
17639     } catch (std::out_of_range& e) {
17640       {
17641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17642       };
17643     } catch (std::exception& e) {
17644       {
17645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17646       };
17647     } catch (...) {
17648       {
17649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17650       };
17651     }
17652   }
17653   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17654   return jresult;
17655 }
17656
17657
17658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
17659   void * jresult ;
17660   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17661   Dali::Property::Index arg2 ;
17662   int arg3 ;
17663   Dali::PropertyCondition *arg4 = 0 ;
17664   Dali::PropertyNotification result;
17665
17666   arg1 = (Dali::Handle *)jarg1;
17667   arg2 = (Dali::Property::Index)jarg2;
17668   arg3 = (int)jarg3;
17669   arg4 = (Dali::PropertyCondition *)jarg4;
17670   if (!arg4) {
17671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17672     return 0;
17673   }
17674   {
17675     try {
17676       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
17677     } catch (std::out_of_range& e) {
17678       {
17679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17680       };
17681     } catch (std::exception& e) {
17682       {
17683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17684       };
17685     } catch (...) {
17686       {
17687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17688       };
17689     }
17690   }
17691   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17692   return jresult;
17693 }
17694
17695
17696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
17697   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17698   Dali::PropertyNotification arg2 ;
17699   Dali::PropertyNotification *argp2 ;
17700
17701   arg1 = (Dali::Handle *)jarg1;
17702   argp2 = (Dali::PropertyNotification *)jarg2;
17703   if (!argp2) {
17704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
17705     return ;
17706   }
17707   arg2 = *argp2;
17708   {
17709     try {
17710       (arg1)->RemovePropertyNotification(arg2);
17711     } catch (std::out_of_range& e) {
17712       {
17713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17714       };
17715     } catch (std::exception& e) {
17716       {
17717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17718       };
17719     } catch (...) {
17720       {
17721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17722       };
17723     }
17724   }
17725 }
17726
17727
17728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
17729   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17730
17731   arg1 = (Dali::Handle *)jarg1;
17732   {
17733     try {
17734       (arg1)->RemovePropertyNotifications();
17735     } catch (std::out_of_range& e) {
17736       {
17737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17738       };
17739     } catch (std::exception& e) {
17740       {
17741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17742       };
17743     } catch (...) {
17744       {
17745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17746       };
17747     }
17748   }
17749 }
17750
17751
17752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
17753   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17754
17755   arg1 = (Dali::Handle *)jarg1;
17756   {
17757     try {
17758       (arg1)->RemoveConstraints();
17759     } catch (std::out_of_range& e) {
17760       {
17761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17762       };
17763     } catch (std::exception& e) {
17764       {
17765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17766       };
17767     } catch (...) {
17768       {
17769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17770       };
17771     }
17772   }
17773 }
17774
17775
17776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
17777   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17778   unsigned int arg2 ;
17779
17780   arg1 = (Dali::Handle *)jarg1;
17781   arg2 = (unsigned int)jarg2;
17782   {
17783     try {
17784       (arg1)->RemoveConstraints(arg2);
17785     } catch (std::out_of_range& e) {
17786       {
17787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17788       };
17789     } catch (std::exception& e) {
17790       {
17791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17792       };
17793     } catch (...) {
17794       {
17795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17796       };
17797     }
17798   }
17799 }
17800
17801
17802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
17803   int jresult ;
17804   Dali::Property::Index result;
17805
17806   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
17807   jresult = result;
17808   return jresult;
17809 }
17810
17811
17812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
17813   void * jresult ;
17814   Dali::Handle result;
17815
17816   {
17817     try {
17818       result = Dali::WeightObject::New();
17819     } catch (std::out_of_range& e) {
17820       {
17821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17822       };
17823     } catch (std::exception& e) {
17824       {
17825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17826       };
17827     } catch (...) {
17828       {
17829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17830       };
17831     }
17832   }
17833   jresult = new Dali::Handle((const Dali::Handle &)result);
17834   return jresult;
17835 }
17836
17837
17838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
17839   void * jresult ;
17840   Dali::TypeInfo *result = 0 ;
17841
17842   {
17843     try {
17844       result = (Dali::TypeInfo *)new Dali::TypeInfo();
17845     } catch (std::out_of_range& e) {
17846       {
17847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17848       };
17849     } catch (std::exception& e) {
17850       {
17851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17852       };
17853     } catch (...) {
17854       {
17855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17856       };
17857     }
17858   }
17859   jresult = (void *)result;
17860   return jresult;
17861 }
17862
17863
17864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
17865   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
17866
17867   arg1 = (Dali::TypeInfo *)jarg1;
17868   {
17869     try {
17870       delete arg1;
17871     } catch (std::out_of_range& e) {
17872       {
17873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17874       };
17875     } catch (std::exception& e) {
17876       {
17877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17878       };
17879     } catch (...) {
17880       {
17881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17882       };
17883     }
17884   }
17885 }
17886
17887
17888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
17889   void * jresult ;
17890   Dali::TypeInfo *arg1 = 0 ;
17891   Dali::TypeInfo *result = 0 ;
17892
17893   arg1 = (Dali::TypeInfo *)jarg1;
17894   if (!arg1) {
17895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
17896     return 0;
17897   }
17898   {
17899     try {
17900       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
17901     } catch (std::out_of_range& e) {
17902       {
17903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17904       };
17905     } catch (std::exception& e) {
17906       {
17907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17908       };
17909     } catch (...) {
17910       {
17911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17912       };
17913     }
17914   }
17915   jresult = (void *)result;
17916   return jresult;
17917 }
17918
17919
17920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
17921   void * jresult ;
17922   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
17923   Dali::TypeInfo *arg2 = 0 ;
17924   Dali::TypeInfo *result = 0 ;
17925
17926   arg1 = (Dali::TypeInfo *)jarg1;
17927   arg2 = (Dali::TypeInfo *)jarg2;
17928   if (!arg2) {
17929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
17930     return 0;
17931   }
17932   {
17933     try {
17934       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
17935     } catch (std::out_of_range& e) {
17936       {
17937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17938       };
17939     } catch (std::exception& e) {
17940       {
17941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17942       };
17943     } catch (...) {
17944       {
17945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17946       };
17947     }
17948   }
17949   jresult = (void *)result;
17950   return jresult;
17951 }
17952
17953
17954 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
17955   char * jresult ;
17956   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
17957   std::string *result = 0 ;
17958
17959   arg1 = (Dali::TypeInfo *)jarg1;
17960   {
17961     try {
17962       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
17963     } catch (std::out_of_range& e) {
17964       {
17965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17966       };
17967     } catch (std::exception& e) {
17968       {
17969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17970       };
17971     } catch (...) {
17972       {
17973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17974       };
17975     }
17976   }
17977   jresult = SWIG_csharp_string_callback(result->c_str());
17978   return jresult;
17979 }
17980
17981
17982 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
17983   char * jresult ;
17984   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
17985   std::string *result = 0 ;
17986
17987   arg1 = (Dali::TypeInfo *)jarg1;
17988   {
17989     try {
17990       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
17991     } catch (std::out_of_range& e) {
17992       {
17993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17994       };
17995     } catch (std::exception& e) {
17996       {
17997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17998       };
17999     } catch (...) {
18000       {
18001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18002       };
18003     }
18004   }
18005   jresult = SWIG_csharp_string_callback(result->c_str());
18006   return jresult;
18007 }
18008
18009
18010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18011   void * jresult ;
18012   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18013   Dali::BaseHandle result;
18014
18015   arg1 = (Dali::TypeInfo *)jarg1;
18016   {
18017     try {
18018       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18019     } catch (std::out_of_range& e) {
18020       {
18021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18022       };
18023     } catch (std::exception& e) {
18024       {
18025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18026       };
18027     } catch (...) {
18028       {
18029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18030       };
18031     }
18032   }
18033   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18034   return jresult;
18035 }
18036
18037
18038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_GetCreator(void * jarg1) {
18039   void * jresult ;
18040   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18041   Dali::TypeInfo::CreateFunction result;
18042
18043   arg1 = (Dali::TypeInfo *)jarg1;
18044   {
18045     try {
18046       result = (Dali::TypeInfo::CreateFunction)((Dali::TypeInfo const *)arg1)->GetCreator();
18047     } catch (std::out_of_range& e) {
18048       {
18049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18050       };
18051     } catch (std::exception& e) {
18052       {
18053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18054       };
18055     } catch (...) {
18056       {
18057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18058       };
18059     }
18060   }
18061   jresult = (void *)result;
18062   return jresult;
18063 }
18064
18065
18066 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18067   unsigned long jresult ;
18068   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18069   size_t result;
18070
18071   arg1 = (Dali::TypeInfo *)jarg1;
18072   {
18073     try {
18074       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18075     } catch (std::out_of_range& e) {
18076       {
18077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18078       };
18079     } catch (std::exception& e) {
18080       {
18081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18082       };
18083     } catch (...) {
18084       {
18085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18086       };
18087     }
18088   }
18089   jresult = (unsigned long)result;
18090   return jresult;
18091 }
18092
18093
18094 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18095   char * jresult ;
18096   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18097   size_t arg2 ;
18098   std::string result;
18099
18100   arg1 = (Dali::TypeInfo *)jarg1;
18101   arg2 = (size_t)jarg2;
18102   {
18103     try {
18104       result = (arg1)->GetActionName(arg2);
18105     } catch (std::out_of_range& e) {
18106       {
18107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18108       };
18109     } catch (std::exception& e) {
18110       {
18111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18112       };
18113     } catch (...) {
18114       {
18115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18116       };
18117     }
18118   }
18119   jresult = SWIG_csharp_string_callback((&result)->c_str());
18120   return jresult;
18121 }
18122
18123
18124 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18125   unsigned long jresult ;
18126   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18127   size_t result;
18128
18129   arg1 = (Dali::TypeInfo *)jarg1;
18130   {
18131     try {
18132       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18133     } catch (std::out_of_range& e) {
18134       {
18135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18136       };
18137     } catch (std::exception& e) {
18138       {
18139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18140       };
18141     } catch (...) {
18142       {
18143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18144       };
18145     }
18146   }
18147   jresult = (unsigned long)result;
18148   return jresult;
18149 }
18150
18151
18152 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18153   char * jresult ;
18154   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18155   size_t arg2 ;
18156   std::string result;
18157
18158   arg1 = (Dali::TypeInfo *)jarg1;
18159   arg2 = (size_t)jarg2;
18160   {
18161     try {
18162       result = (arg1)->GetSignalName(arg2);
18163     } catch (std::out_of_range& e) {
18164       {
18165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18166       };
18167     } catch (std::exception& e) {
18168       {
18169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18170       };
18171     } catch (...) {
18172       {
18173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18174       };
18175     }
18176   }
18177   jresult = SWIG_csharp_string_callback((&result)->c_str());
18178   return jresult;
18179 }
18180
18181
18182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18183   unsigned long jresult ;
18184   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18185   size_t result;
18186
18187   arg1 = (Dali::TypeInfo *)jarg1;
18188   {
18189     try {
18190       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18191     } catch (std::out_of_range& e) {
18192       {
18193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18194       };
18195     } catch (std::exception& e) {
18196       {
18197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18198       };
18199     } catch (...) {
18200       {
18201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18202       };
18203     }
18204   }
18205   jresult = (unsigned long)result;
18206   return jresult;
18207 }
18208
18209
18210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18211   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18212   Dali::Property::IndexContainer *arg2 = 0 ;
18213
18214   arg1 = (Dali::TypeInfo *)jarg1;
18215   arg2 = (Dali::Property::IndexContainer *)jarg2;
18216   if (!arg2) {
18217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18218     return ;
18219   }
18220   {
18221     try {
18222       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18223     } catch (std::out_of_range& e) {
18224       {
18225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18226       };
18227     } catch (std::exception& e) {
18228       {
18229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18230       };
18231     } catch (...) {
18232       {
18233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18234       };
18235     }
18236   }
18237 }
18238
18239
18240 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18241   char * jresult ;
18242   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18243   Dali::Property::Index arg2 ;
18244   std::string *result = 0 ;
18245
18246   arg1 = (Dali::TypeInfo *)jarg1;
18247   arg2 = (Dali::Property::Index)jarg2;
18248   {
18249     try {
18250       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18251     } catch (std::out_of_range& e) {
18252       {
18253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18254       };
18255     } catch (std::exception& e) {
18256       {
18257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18258       };
18259     } catch (...) {
18260       {
18261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18262       };
18263     }
18264   }
18265   jresult = SWIG_csharp_string_callback(result->c_str());
18266   return jresult;
18267 }
18268
18269
18270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
18271   float jresult ;
18272   float result;
18273
18274   result = (float)(float)Dali::ParentOrigin::TOP;
18275   jresult = result;
18276   return jresult;
18277 }
18278
18279
18280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
18281   float jresult ;
18282   float result;
18283
18284   result = (float)(float)Dali::ParentOrigin::BOTTOM;
18285   jresult = result;
18286   return jresult;
18287 }
18288
18289
18290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
18291   float jresult ;
18292   float result;
18293
18294   result = (float)(float)Dali::ParentOrigin::LEFT;
18295   jresult = result;
18296   return jresult;
18297 }
18298
18299
18300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
18301   float jresult ;
18302   float result;
18303
18304   result = (float)(float)Dali::ParentOrigin::RIGHT;
18305   jresult = result;
18306   return jresult;
18307 }
18308
18309
18310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
18311   float jresult ;
18312   float result;
18313
18314   result = (float)(float)Dali::ParentOrigin::MIDDLE;
18315   jresult = result;
18316   return jresult;
18317 }
18318
18319
18320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
18321   void * jresult ;
18322   Dali::Vector3 *result = 0 ;
18323
18324   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
18325   jresult = (void *)result;
18326   return jresult;
18327 }
18328
18329
18330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
18331   void * jresult ;
18332   Dali::Vector3 *result = 0 ;
18333
18334   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
18335   jresult = (void *)result;
18336   return jresult;
18337 }
18338
18339
18340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
18341   void * jresult ;
18342   Dali::Vector3 *result = 0 ;
18343
18344   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
18345   jresult = (void *)result;
18346   return jresult;
18347 }
18348
18349
18350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
18351   void * jresult ;
18352   Dali::Vector3 *result = 0 ;
18353
18354   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
18355   jresult = (void *)result;
18356   return jresult;
18357 }
18358
18359
18360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
18361   void * jresult ;
18362   Dali::Vector3 *result = 0 ;
18363
18364   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
18365   jresult = (void *)result;
18366   return jresult;
18367 }
18368
18369
18370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
18371   void * jresult ;
18372   Dali::Vector3 *result = 0 ;
18373
18374   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
18375   jresult = (void *)result;
18376   return jresult;
18377 }
18378
18379
18380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
18381   void * jresult ;
18382   Dali::Vector3 *result = 0 ;
18383
18384   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
18385   jresult = (void *)result;
18386   return jresult;
18387 }
18388
18389
18390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
18391   void * jresult ;
18392   Dali::Vector3 *result = 0 ;
18393
18394   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
18395   jresult = (void *)result;
18396   return jresult;
18397 }
18398
18399
18400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
18401   void * jresult ;
18402   Dali::Vector3 *result = 0 ;
18403
18404   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
18405   jresult = (void *)result;
18406   return jresult;
18407 }
18408
18409
18410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
18411   float jresult ;
18412   float result;
18413
18414   result = (float)(float)Dali::AnchorPoint::TOP;
18415   jresult = result;
18416   return jresult;
18417 }
18418
18419
18420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
18421   float jresult ;
18422   float result;
18423
18424   result = (float)(float)Dali::AnchorPoint::BOTTOM;
18425   jresult = result;
18426   return jresult;
18427 }
18428
18429
18430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
18431   float jresult ;
18432   float result;
18433
18434   result = (float)(float)Dali::AnchorPoint::LEFT;
18435   jresult = result;
18436   return jresult;
18437 }
18438
18439
18440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
18441   float jresult ;
18442   float result;
18443
18444   result = (float)(float)Dali::AnchorPoint::RIGHT;
18445   jresult = result;
18446   return jresult;
18447 }
18448
18449
18450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
18451   float jresult ;
18452   float result;
18453
18454   result = (float)(float)Dali::AnchorPoint::MIDDLE;
18455   jresult = result;
18456   return jresult;
18457 }
18458
18459
18460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
18461   void * jresult ;
18462   Dali::Vector3 *result = 0 ;
18463
18464   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
18465   jresult = (void *)result;
18466   return jresult;
18467 }
18468
18469
18470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
18471   void * jresult ;
18472   Dali::Vector3 *result = 0 ;
18473
18474   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
18475   jresult = (void *)result;
18476   return jresult;
18477 }
18478
18479
18480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
18481   void * jresult ;
18482   Dali::Vector3 *result = 0 ;
18483
18484   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
18485   jresult = (void *)result;
18486   return jresult;
18487 }
18488
18489
18490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
18491   void * jresult ;
18492   Dali::Vector3 *result = 0 ;
18493
18494   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
18495   jresult = (void *)result;
18496   return jresult;
18497 }
18498
18499
18500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
18501   void * jresult ;
18502   Dali::Vector3 *result = 0 ;
18503
18504   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
18505   jresult = (void *)result;
18506   return jresult;
18507 }
18508
18509
18510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
18511   void * jresult ;
18512   Dali::Vector3 *result = 0 ;
18513
18514   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
18515   jresult = (void *)result;
18516   return jresult;
18517 }
18518
18519
18520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
18521   void * jresult ;
18522   Dali::Vector3 *result = 0 ;
18523
18524   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
18525   jresult = (void *)result;
18526   return jresult;
18527 }
18528
18529
18530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
18531   void * jresult ;
18532   Dali::Vector3 *result = 0 ;
18533
18534   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
18535   jresult = (void *)result;
18536   return jresult;
18537 }
18538
18539
18540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
18541   void * jresult ;
18542   Dali::Vector3 *result = 0 ;
18543
18544   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
18545   jresult = (void *)result;
18546   return jresult;
18547 }
18548
18549
18550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
18551   void * jresult ;
18552   Dali::Vector4 *result = 0 ;
18553
18554   result = (Dali::Vector4 *)&Dali::Color::BLACK;
18555   jresult = (void *)result;
18556   return jresult;
18557 }
18558
18559
18560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
18561   void * jresult ;
18562   Dali::Vector4 *result = 0 ;
18563
18564   result = (Dali::Vector4 *)&Dali::Color::WHITE;
18565   jresult = (void *)result;
18566   return jresult;
18567 }
18568
18569
18570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
18571   void * jresult ;
18572   Dali::Vector4 *result = 0 ;
18573
18574   result = (Dali::Vector4 *)&Dali::Color::RED;
18575   jresult = (void *)result;
18576   return jresult;
18577 }
18578
18579
18580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
18581   void * jresult ;
18582   Dali::Vector4 *result = 0 ;
18583
18584   result = (Dali::Vector4 *)&Dali::Color::GREEN;
18585   jresult = (void *)result;
18586   return jresult;
18587 }
18588
18589
18590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
18591   void * jresult ;
18592   Dali::Vector4 *result = 0 ;
18593
18594   result = (Dali::Vector4 *)&Dali::Color::BLUE;
18595   jresult = (void *)result;
18596   return jresult;
18597 }
18598
18599
18600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
18601   void * jresult ;
18602   Dali::Vector4 *result = 0 ;
18603
18604   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
18605   jresult = (void *)result;
18606   return jresult;
18607 }
18608
18609
18610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
18611   void * jresult ;
18612   Dali::Vector4 *result = 0 ;
18613
18614   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
18615   jresult = (void *)result;
18616   return jresult;
18617 }
18618
18619
18620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
18621   void * jresult ;
18622   Dali::Vector4 *result = 0 ;
18623
18624   result = (Dali::Vector4 *)&Dali::Color::CYAN;
18625   jresult = (void *)result;
18626   return jresult;
18627 }
18628
18629
18630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
18631   void * jresult ;
18632   Dali::Vector4 *result = 0 ;
18633
18634   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
18635   jresult = (void *)result;
18636   return jresult;
18637 }
18638
18639
18640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
18641   float jresult ;
18642   float result;
18643
18644   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
18645   jresult = result;
18646   return jresult;
18647 }
18648
18649
18650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
18651   float jresult ;
18652   float result;
18653
18654   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
18655   jresult = result;
18656   return jresult;
18657 }
18658
18659
18660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
18661   float jresult ;
18662   float result;
18663
18664   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
18665   jresult = result;
18666   return jresult;
18667 }
18668
18669
18670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
18671   float jresult ;
18672   float result;
18673
18674   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
18675   jresult = result;
18676   return jresult;
18677 }
18678
18679
18680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
18681   float jresult ;
18682   float result;
18683
18684   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
18685   jresult = result;
18686   return jresult;
18687 }
18688
18689
18690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
18691   float jresult ;
18692   float result;
18693
18694   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
18695   jresult = result;
18696   return jresult;
18697 }
18698
18699
18700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
18701   float jresult ;
18702   float result;
18703
18704   result = (float)(float)Dali::Math::PI;
18705   jresult = result;
18706   return jresult;
18707 }
18708
18709
18710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
18711   float jresult ;
18712   float result;
18713
18714   result = (float)(float)Dali::Math::PI_2;
18715   jresult = result;
18716   return jresult;
18717 }
18718
18719
18720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
18721   float jresult ;
18722   float result;
18723
18724   result = (float)(float)Dali::Math::PI_4;
18725   jresult = result;
18726   return jresult;
18727 }
18728
18729
18730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
18731   float jresult ;
18732   float result;
18733
18734   result = (float)(float)Dali::Math::PI_OVER_180;
18735   jresult = result;
18736   return jresult;
18737 }
18738
18739
18740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
18741   float jresult ;
18742   float result;
18743
18744   result = (float)(float)Dali::Math::ONE80_OVER_PI;
18745   jresult = result;
18746   return jresult;
18747 }
18748
18749
18750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
18751   int jresult ;
18752   Dali::ResizePolicy::Type result;
18753
18754   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
18755   jresult = (int)result;
18756   return jresult;
18757 }
18758
18759
18760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
18761   unsigned long jresult ;
18762   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
18763   Dali::VectorBase::SizeType result;
18764
18765   arg1 = (Dali::VectorBase *)jarg1;
18766   {
18767     try {
18768       result = ((Dali::VectorBase const *)arg1)->Count();
18769     } catch (std::out_of_range& e) {
18770       {
18771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18772       };
18773     } catch (std::exception& e) {
18774       {
18775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18776       };
18777     } catch (...) {
18778       {
18779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18780       };
18781     }
18782   }
18783   jresult = (unsigned long)result;
18784   return jresult;
18785 }
18786
18787
18788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
18789   unsigned long jresult ;
18790   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
18791   Dali::VectorBase::SizeType result;
18792
18793   arg1 = (Dali::VectorBase *)jarg1;
18794   {
18795     try {
18796       result = ((Dali::VectorBase const *)arg1)->Size();
18797     } catch (std::out_of_range& e) {
18798       {
18799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18800       };
18801     } catch (std::exception& e) {
18802       {
18803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18804       };
18805     } catch (...) {
18806       {
18807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18808       };
18809     }
18810   }
18811   jresult = (unsigned long)result;
18812   return jresult;
18813 }
18814
18815
18816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
18817   unsigned int jresult ;
18818   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
18819   bool result;
18820
18821   arg1 = (Dali::VectorBase *)jarg1;
18822   {
18823     try {
18824       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
18825     } catch (std::out_of_range& e) {
18826       {
18827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18828       };
18829     } catch (std::exception& e) {
18830       {
18831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18832       };
18833     } catch (...) {
18834       {
18835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18836       };
18837     }
18838   }
18839   jresult = result;
18840   return jresult;
18841 }
18842
18843
18844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
18845   unsigned long jresult ;
18846   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
18847   Dali::VectorBase::SizeType result;
18848
18849   arg1 = (Dali::VectorBase *)jarg1;
18850   {
18851     try {
18852       result = ((Dali::VectorBase const *)arg1)->Capacity();
18853     } catch (std::out_of_range& e) {
18854       {
18855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18856       };
18857     } catch (std::exception& e) {
18858       {
18859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18860       };
18861     } catch (...) {
18862       {
18863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18864       };
18865     }
18866   }
18867   jresult = (unsigned long)result;
18868   return jresult;
18869 }
18870
18871
18872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
18873   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
18874
18875   arg1 = (Dali::VectorBase *)jarg1;
18876   {
18877     try {
18878       (arg1)->Release();
18879     } catch (std::out_of_range& e) {
18880       {
18881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18882       };
18883     } catch (std::exception& e) {
18884       {
18885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18886       };
18887     } catch (...) {
18888       {
18889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18890       };
18891     }
18892   }
18893 }
18894
18895
18896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
18897   void * jresult ;
18898   Dali::Image *result = 0 ;
18899
18900   {
18901     try {
18902       result = (Dali::Image *)new Dali::Image();
18903     } catch (std::out_of_range& e) {
18904       {
18905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18906       };
18907     } catch (std::exception& e) {
18908       {
18909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18910       };
18911     } catch (...) {
18912       {
18913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18914       };
18915     }
18916   }
18917   jresult = (void *)result;
18918   return jresult;
18919 }
18920
18921
18922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
18923   Dali::Image *arg1 = (Dali::Image *) 0 ;
18924
18925   arg1 = (Dali::Image *)jarg1;
18926   {
18927     try {
18928       delete arg1;
18929     } catch (std::out_of_range& e) {
18930       {
18931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18932       };
18933     } catch (std::exception& e) {
18934       {
18935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18936       };
18937     } catch (...) {
18938       {
18939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18940       };
18941     }
18942   }
18943 }
18944
18945
18946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
18947   void * jresult ;
18948   Dali::Image *arg1 = 0 ;
18949   Dali::Image *result = 0 ;
18950
18951   arg1 = (Dali::Image *)jarg1;
18952   if (!arg1) {
18953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
18954     return 0;
18955   }
18956   {
18957     try {
18958       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
18959     } catch (std::out_of_range& e) {
18960       {
18961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18962       };
18963     } catch (std::exception& e) {
18964       {
18965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18966       };
18967     } catch (...) {
18968       {
18969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18970       };
18971     }
18972   }
18973   jresult = (void *)result;
18974   return jresult;
18975 }
18976
18977
18978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
18979   void * jresult ;
18980   Dali::Image *arg1 = (Dali::Image *) 0 ;
18981   Dali::Image *arg2 = 0 ;
18982   Dali::Image *result = 0 ;
18983
18984   arg1 = (Dali::Image *)jarg1;
18985   arg2 = (Dali::Image *)jarg2;
18986   if (!arg2) {
18987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
18988     return 0;
18989   }
18990   {
18991     try {
18992       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
18993     } catch (std::out_of_range& e) {
18994       {
18995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18996       };
18997     } catch (std::exception& e) {
18998       {
18999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19000       };
19001     } catch (...) {
19002       {
19003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19004       };
19005     }
19006   }
19007   jresult = (void *)result;
19008   return jresult;
19009 }
19010
19011
19012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
19013   void * jresult ;
19014   Dali::BaseHandle arg1 ;
19015   Dali::BaseHandle *argp1 ;
19016   Dali::Image result;
19017
19018   argp1 = (Dali::BaseHandle *)jarg1;
19019   if (!argp1) {
19020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19021     return 0;
19022   }
19023   arg1 = *argp1;
19024   {
19025     try {
19026       result = Dali::Image::DownCast(arg1);
19027     } catch (std::out_of_range& e) {
19028       {
19029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19030       };
19031     } catch (std::exception& e) {
19032       {
19033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19034       };
19035     } catch (...) {
19036       {
19037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19038       };
19039     }
19040   }
19041   jresult = new Dali::Image((const Dali::Image &)result);
19042   return jresult;
19043 }
19044
19045
19046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
19047   unsigned int jresult ;
19048   Dali::Image *arg1 = (Dali::Image *) 0 ;
19049   unsigned int result;
19050
19051   arg1 = (Dali::Image *)jarg1;
19052   {
19053     try {
19054       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
19055     } catch (std::out_of_range& e) {
19056       {
19057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19058       };
19059     } catch (std::exception& e) {
19060       {
19061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19062       };
19063     } catch (...) {
19064       {
19065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19066       };
19067     }
19068   }
19069   jresult = result;
19070   return jresult;
19071 }
19072
19073
19074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
19075   unsigned int jresult ;
19076   Dali::Image *arg1 = (Dali::Image *) 0 ;
19077   unsigned int result;
19078
19079   arg1 = (Dali::Image *)jarg1;
19080   {
19081     try {
19082       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
19083     } catch (std::out_of_range& e) {
19084       {
19085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19086       };
19087     } catch (std::exception& e) {
19088       {
19089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19090       };
19091     } catch (...) {
19092       {
19093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19094       };
19095     }
19096   }
19097   jresult = result;
19098   return jresult;
19099 }
19100
19101
19102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
19103   void * jresult ;
19104   Dali::Image *arg1 = (Dali::Image *) 0 ;
19105   Dali::Image::ImageSignalType *result = 0 ;
19106
19107   arg1 = (Dali::Image *)jarg1;
19108   {
19109     try {
19110       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
19111     } catch (std::out_of_range& e) {
19112       {
19113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19114       };
19115     } catch (std::exception& e) {
19116       {
19117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19118       };
19119     } catch (...) {
19120       {
19121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19122       };
19123     }
19124   }
19125   jresult = (void *)result;
19126   return jresult;
19127 }
19128
19129
19130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
19131   int jresult ;
19132   Dali::Pixel::Format result;
19133
19134   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
19135   jresult = (int)result;
19136   return jresult;
19137 }
19138
19139
19140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
19141   int jresult ;
19142   Dali::Pixel::Format result;
19143
19144   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
19145   jresult = (int)result;
19146   return jresult;
19147 }
19148
19149
19150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
19151   unsigned int jresult ;
19152   Dali::Pixel::Format arg1 ;
19153   bool result;
19154
19155   arg1 = (Dali::Pixel::Format)jarg1;
19156   {
19157     try {
19158       result = (bool)Dali::Pixel::HasAlpha(arg1);
19159     } catch (std::out_of_range& e) {
19160       {
19161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19162       };
19163     } catch (std::exception& e) {
19164       {
19165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19166       };
19167     } catch (...) {
19168       {
19169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19170       };
19171     }
19172   }
19173   jresult = result;
19174   return jresult;
19175 }
19176
19177
19178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
19179   unsigned int jresult ;
19180   Dali::Pixel::Format arg1 ;
19181   unsigned int result;
19182
19183   arg1 = (Dali::Pixel::Format)jarg1;
19184   {
19185     try {
19186       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
19187     } catch (std::out_of_range& e) {
19188       {
19189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19190       };
19191     } catch (std::exception& e) {
19192       {
19193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (...) {
19196       {
19197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19198       };
19199     }
19200   }
19201   jresult = result;
19202   return jresult;
19203 }
19204
19205
19206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
19207   Dali::Pixel::Format arg1 ;
19208   int *arg2 = 0 ;
19209   int *arg3 = 0 ;
19210
19211   arg1 = (Dali::Pixel::Format)jarg1;
19212   arg2 = (int *)jarg2;
19213   if (!arg2) {
19214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
19215     return ;
19216   }
19217   arg3 = (int *)jarg3;
19218   if (!arg3) {
19219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
19220     return ;
19221   }
19222   {
19223     try {
19224       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
19225     } catch (std::out_of_range& e) {
19226       {
19227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19228       };
19229     } catch (std::exception& e) {
19230       {
19231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19232       };
19233     } catch (...) {
19234       {
19235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19236       };
19237     }
19238   }
19239 }
19240
19241
19242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
19243   void * jresult ;
19244   unsigned char *arg1 = (unsigned char *) 0 ;
19245   unsigned int arg2 ;
19246   unsigned int arg3 ;
19247   unsigned int arg4 ;
19248   Dali::Pixel::Format arg5 ;
19249   Dali::PixelData::ReleaseFunction arg6 ;
19250   Dali::PixelData result;
19251
19252   arg1 = jarg1;
19253   arg2 = (unsigned int)jarg2;
19254   arg3 = (unsigned int)jarg3;
19255   arg4 = (unsigned int)jarg4;
19256   arg5 = (Dali::Pixel::Format)jarg5;
19257   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
19258   {
19259     try {
19260       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
19261     } catch (std::out_of_range& e) {
19262       {
19263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (std::exception& e) {
19266       {
19267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19268       };
19269     } catch (...) {
19270       {
19271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19272       };
19273     }
19274   }
19275   jresult = new Dali::PixelData((const Dali::PixelData &)result);
19276
19277
19278   return jresult;
19279 }
19280
19281
19282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
19283   void * jresult ;
19284   Dali::PixelData *result = 0 ;
19285
19286   {
19287     try {
19288       result = (Dali::PixelData *)new Dali::PixelData();
19289     } catch (std::out_of_range& e) {
19290       {
19291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19292       };
19293     } catch (std::exception& e) {
19294       {
19295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19296       };
19297     } catch (...) {
19298       {
19299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19300       };
19301     }
19302   }
19303   jresult = (void *)result;
19304   return jresult;
19305 }
19306
19307
19308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
19309   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
19310
19311   arg1 = (Dali::PixelData *)jarg1;
19312   {
19313     try {
19314       delete arg1;
19315     } catch (std::out_of_range& e) {
19316       {
19317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19318       };
19319     } catch (std::exception& e) {
19320       {
19321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19322       };
19323     } catch (...) {
19324       {
19325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19326       };
19327     }
19328   }
19329 }
19330
19331
19332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
19333   void * jresult ;
19334   Dali::PixelData *arg1 = 0 ;
19335   Dali::PixelData *result = 0 ;
19336
19337   arg1 = (Dali::PixelData *)jarg1;
19338   if (!arg1) {
19339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
19340     return 0;
19341   }
19342   {
19343     try {
19344       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
19345     } catch (std::out_of_range& e) {
19346       {
19347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19348       };
19349     } catch (std::exception& e) {
19350       {
19351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19352       };
19353     } catch (...) {
19354       {
19355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19356       };
19357     }
19358   }
19359   jresult = (void *)result;
19360   return jresult;
19361 }
19362
19363
19364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
19365   void * jresult ;
19366   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
19367   Dali::PixelData *arg2 = 0 ;
19368   Dali::PixelData *result = 0 ;
19369
19370   arg1 = (Dali::PixelData *)jarg1;
19371   arg2 = (Dali::PixelData *)jarg2;
19372   if (!arg2) {
19373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
19374     return 0;
19375   }
19376   {
19377     try {
19378       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
19379     } catch (std::out_of_range& e) {
19380       {
19381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19382       };
19383     } catch (std::exception& e) {
19384       {
19385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19386       };
19387     } catch (...) {
19388       {
19389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19390       };
19391     }
19392   }
19393   jresult = (void *)result;
19394   return jresult;
19395 }
19396
19397
19398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
19399   unsigned int jresult ;
19400   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
19401   unsigned int result;
19402
19403   arg1 = (Dali::PixelData *)jarg1;
19404   {
19405     try {
19406       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
19407     } catch (std::out_of_range& e) {
19408       {
19409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19410       };
19411     } catch (std::exception& e) {
19412       {
19413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19414       };
19415     } catch (...) {
19416       {
19417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19418       };
19419     }
19420   }
19421   jresult = result;
19422   return jresult;
19423 }
19424
19425
19426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
19427   unsigned int jresult ;
19428   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
19429   unsigned int result;
19430
19431   arg1 = (Dali::PixelData *)jarg1;
19432   {
19433     try {
19434       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
19435     } catch (std::out_of_range& e) {
19436       {
19437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19438       };
19439     } catch (std::exception& e) {
19440       {
19441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19442       };
19443     } catch (...) {
19444       {
19445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19446       };
19447     }
19448   }
19449   jresult = result;
19450   return jresult;
19451 }
19452
19453
19454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
19455   int jresult ;
19456   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
19457   Dali::Pixel::Format result;
19458
19459   arg1 = (Dali::PixelData *)jarg1;
19460   {
19461     try {
19462       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
19463     } catch (std::out_of_range& e) {
19464       {
19465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19466       };
19467     } catch (std::exception& e) {
19468       {
19469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19470       };
19471     } catch (...) {
19472       {
19473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19474       };
19475     }
19476   }
19477   jresult = (int)result;
19478   return jresult;
19479 }
19480
19481
19482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
19483   unsigned int jresult ;
19484   unsigned int result;
19485
19486   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
19487   jresult = result;
19488   return jresult;
19489 }
19490
19491
19492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
19493   unsigned int jresult ;
19494   unsigned int result;
19495
19496   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
19497   jresult = result;
19498   return jresult;
19499 }
19500
19501
19502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
19503   unsigned int jresult ;
19504   unsigned int result;
19505
19506   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
19507   jresult = result;
19508   return jresult;
19509 }
19510
19511
19512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
19513   unsigned int jresult ;
19514   unsigned int result;
19515
19516   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
19517   jresult = result;
19518   return jresult;
19519 }
19520
19521
19522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
19523   unsigned int jresult ;
19524   unsigned int result;
19525
19526   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
19527   jresult = result;
19528   return jresult;
19529 }
19530
19531
19532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
19533   unsigned int jresult ;
19534   unsigned int result;
19535
19536   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
19537   jresult = result;
19538   return jresult;
19539 }
19540
19541
19542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
19543   void * jresult ;
19544   Dali::TextureType::Type arg1 ;
19545   Dali::Pixel::Format arg2 ;
19546   unsigned int arg3 ;
19547   unsigned int arg4 ;
19548   Dali::Texture result;
19549
19550   arg1 = (Dali::TextureType::Type)jarg1;
19551   arg2 = (Dali::Pixel::Format)jarg2;
19552   arg3 = (unsigned int)jarg3;
19553   arg4 = (unsigned int)jarg4;
19554   {
19555     try {
19556       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
19557     } catch (std::out_of_range& e) {
19558       {
19559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19560       };
19561     } catch (std::exception& e) {
19562       {
19563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19564       };
19565     } catch (...) {
19566       {
19567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19568       };
19569     }
19570   }
19571   jresult = new Dali::Texture((const Dali::Texture &)result);
19572   return jresult;
19573 }
19574
19575
19576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
19577   void * jresult ;
19578   NativeImageInterface *arg1 = 0 ;
19579   Dali::Texture result;
19580
19581   arg1 = (NativeImageInterface *)jarg1;
19582   if (!arg1) {
19583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
19584     return 0;
19585   }
19586   {
19587     try {
19588       result = Dali::Texture::New(*arg1);
19589     } catch (std::out_of_range& e) {
19590       {
19591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19592       };
19593     } catch (std::exception& e) {
19594       {
19595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19596       };
19597     } catch (...) {
19598       {
19599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19600       };
19601     }
19602   }
19603   jresult = new Dali::Texture((const Dali::Texture &)result);
19604   return jresult;
19605 }
19606
19607
19608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
19609   void * jresult ;
19610   Dali::Texture *result = 0 ;
19611
19612   {
19613     try {
19614       result = (Dali::Texture *)new Dali::Texture();
19615     } catch (std::out_of_range& e) {
19616       {
19617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19618       };
19619     } catch (std::exception& e) {
19620       {
19621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19622       };
19623     } catch (...) {
19624       {
19625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19626       };
19627     }
19628   }
19629   jresult = (void *)result;
19630   return jresult;
19631 }
19632
19633
19634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
19635   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
19636
19637   arg1 = (Dali::Texture *)jarg1;
19638   {
19639     try {
19640       delete arg1;
19641     } catch (std::out_of_range& e) {
19642       {
19643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19644       };
19645     } catch (std::exception& e) {
19646       {
19647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19648       };
19649     } catch (...) {
19650       {
19651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19652       };
19653     }
19654   }
19655 }
19656
19657
19658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
19659   void * jresult ;
19660   Dali::Texture *arg1 = 0 ;
19661   Dali::Texture *result = 0 ;
19662
19663   arg1 = (Dali::Texture *)jarg1;
19664   if (!arg1) {
19665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
19666     return 0;
19667   }
19668   {
19669     try {
19670       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
19671     } catch (std::out_of_range& e) {
19672       {
19673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19674       };
19675     } catch (std::exception& e) {
19676       {
19677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19678       };
19679     } catch (...) {
19680       {
19681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19682       };
19683     }
19684   }
19685   jresult = (void *)result;
19686   return jresult;
19687 }
19688
19689
19690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
19691   void * jresult ;
19692   Dali::BaseHandle arg1 ;
19693   Dali::BaseHandle *argp1 ;
19694   Dali::Texture result;
19695
19696   argp1 = (Dali::BaseHandle *)jarg1;
19697   if (!argp1) {
19698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19699     return 0;
19700   }
19701   arg1 = *argp1;
19702   {
19703     try {
19704       result = Dali::Texture::DownCast(arg1);
19705     } catch (std::out_of_range& e) {
19706       {
19707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19708       };
19709     } catch (std::exception& e) {
19710       {
19711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19712       };
19713     } catch (...) {
19714       {
19715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19716       };
19717     }
19718   }
19719   jresult = new Dali::Texture((const Dali::Texture &)result);
19720   return jresult;
19721 }
19722
19723
19724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
19725   void * jresult ;
19726   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
19727   Dali::Texture *arg2 = 0 ;
19728   Dali::Texture *result = 0 ;
19729
19730   arg1 = (Dali::Texture *)jarg1;
19731   arg2 = (Dali::Texture *)jarg2;
19732   if (!arg2) {
19733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
19734     return 0;
19735   }
19736   {
19737     try {
19738       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
19739     } catch (std::out_of_range& e) {
19740       {
19741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19742       };
19743     } catch (std::exception& e) {
19744       {
19745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19746       };
19747     } catch (...) {
19748       {
19749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19750       };
19751     }
19752   }
19753   jresult = (void *)result;
19754   return jresult;
19755 }
19756
19757
19758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
19759   unsigned int jresult ;
19760   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
19761   Dali::PixelData arg2 ;
19762   Dali::PixelData *argp2 ;
19763   bool result;
19764
19765   arg1 = (Dali::Texture *)jarg1;
19766   argp2 = (Dali::PixelData *)jarg2;
19767   if (!argp2) {
19768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
19769     return 0;
19770   }
19771   arg2 = *argp2;
19772   {
19773     try {
19774       result = (bool)(arg1)->Upload(arg2);
19775     } catch (std::out_of_range& e) {
19776       {
19777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19778       };
19779     } catch (std::exception& e) {
19780       {
19781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19782       };
19783     } catch (...) {
19784       {
19785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19786       };
19787     }
19788   }
19789   jresult = result;
19790   return jresult;
19791 }
19792
19793
19794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
19795   unsigned int jresult ;
19796   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
19797   Dali::PixelData arg2 ;
19798   unsigned int arg3 ;
19799   unsigned int arg4 ;
19800   unsigned int arg5 ;
19801   unsigned int arg6 ;
19802   unsigned int arg7 ;
19803   unsigned int arg8 ;
19804   Dali::PixelData *argp2 ;
19805   bool result;
19806
19807   arg1 = (Dali::Texture *)jarg1;
19808   argp2 = (Dali::PixelData *)jarg2;
19809   if (!argp2) {
19810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
19811     return 0;
19812   }
19813   arg2 = *argp2;
19814   arg3 = (unsigned int)jarg3;
19815   arg4 = (unsigned int)jarg4;
19816   arg5 = (unsigned int)jarg5;
19817   arg6 = (unsigned int)jarg6;
19818   arg7 = (unsigned int)jarg7;
19819   arg8 = (unsigned int)jarg8;
19820   {
19821     try {
19822       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
19823     } catch (std::out_of_range& e) {
19824       {
19825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19826       };
19827     } catch (std::exception& e) {
19828       {
19829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19830       };
19831     } catch (...) {
19832       {
19833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19834       };
19835     }
19836   }
19837   jresult = result;
19838   return jresult;
19839 }
19840
19841
19842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
19843   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
19844
19845   arg1 = (Dali::Texture *)jarg1;
19846   {
19847     try {
19848       (arg1)->GenerateMipmaps();
19849     } catch (std::out_of_range& e) {
19850       {
19851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19852       };
19853     } catch (std::exception& e) {
19854       {
19855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19856       };
19857     } catch (...) {
19858       {
19859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19860       };
19861     }
19862   }
19863 }
19864
19865
19866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
19867   unsigned int jresult ;
19868   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
19869   unsigned int result;
19870
19871   arg1 = (Dali::Texture *)jarg1;
19872   {
19873     try {
19874       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
19875     } catch (std::out_of_range& e) {
19876       {
19877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19878       };
19879     } catch (std::exception& e) {
19880       {
19881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19882       };
19883     } catch (...) {
19884       {
19885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19886       };
19887     }
19888   }
19889   jresult = result;
19890   return jresult;
19891 }
19892
19893
19894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
19895   unsigned int jresult ;
19896   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
19897   unsigned int result;
19898
19899   arg1 = (Dali::Texture *)jarg1;
19900   {
19901     try {
19902       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
19903     } catch (std::out_of_range& e) {
19904       {
19905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19906       };
19907     } catch (std::exception& e) {
19908       {
19909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19910       };
19911     } catch (...) {
19912       {
19913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19914       };
19915     }
19916   }
19917   jresult = result;
19918   return jresult;
19919 }
19920
19921
19922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
19923   void * jresult ;
19924   Dali::Sampler result;
19925
19926   {
19927     try {
19928       result = Dali::Sampler::New();
19929     } catch (std::out_of_range& e) {
19930       {
19931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19932       };
19933     } catch (std::exception& e) {
19934       {
19935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19936       };
19937     } catch (...) {
19938       {
19939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19940       };
19941     }
19942   }
19943   jresult = new Dali::Sampler((const Dali::Sampler &)result);
19944   return jresult;
19945 }
19946
19947
19948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
19949   void * jresult ;
19950   Dali::Sampler *result = 0 ;
19951
19952   {
19953     try {
19954       result = (Dali::Sampler *)new Dali::Sampler();
19955     } catch (std::out_of_range& e) {
19956       {
19957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19958       };
19959     } catch (std::exception& e) {
19960       {
19961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19962       };
19963     } catch (...) {
19964       {
19965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19966       };
19967     }
19968   }
19969   jresult = (void *)result;
19970   return jresult;
19971 }
19972
19973
19974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
19975   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
19976
19977   arg1 = (Dali::Sampler *)jarg1;
19978   {
19979     try {
19980       delete arg1;
19981     } catch (std::out_of_range& e) {
19982       {
19983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19984       };
19985     } catch (std::exception& e) {
19986       {
19987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19988       };
19989     } catch (...) {
19990       {
19991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19992       };
19993     }
19994   }
19995 }
19996
19997
19998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
19999   void * jresult ;
20000   Dali::Sampler *arg1 = 0 ;
20001   Dali::Sampler *result = 0 ;
20002
20003   arg1 = (Dali::Sampler *)jarg1;
20004   if (!arg1) {
20005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
20006     return 0;
20007   }
20008   {
20009     try {
20010       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
20011     } catch (std::out_of_range& e) {
20012       {
20013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20014       };
20015     } catch (std::exception& e) {
20016       {
20017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20018       };
20019     } catch (...) {
20020       {
20021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20022       };
20023     }
20024   }
20025   jresult = (void *)result;
20026   return jresult;
20027 }
20028
20029
20030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
20031   void * jresult ;
20032   Dali::BaseHandle arg1 ;
20033   Dali::BaseHandle *argp1 ;
20034   Dali::Sampler result;
20035
20036   argp1 = (Dali::BaseHandle *)jarg1;
20037   if (!argp1) {
20038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20039     return 0;
20040   }
20041   arg1 = *argp1;
20042   {
20043     try {
20044       result = Dali::Sampler::DownCast(arg1);
20045     } catch (std::out_of_range& e) {
20046       {
20047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20048       };
20049     } catch (std::exception& e) {
20050       {
20051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20052       };
20053     } catch (...) {
20054       {
20055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20056       };
20057     }
20058   }
20059   jresult = new Dali::Sampler((const Dali::Sampler &)result);
20060   return jresult;
20061 }
20062
20063
20064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
20065   void * jresult ;
20066   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
20067   Dali::Sampler *arg2 = 0 ;
20068   Dali::Sampler *result = 0 ;
20069
20070   arg1 = (Dali::Sampler *)jarg1;
20071   arg2 = (Dali::Sampler *)jarg2;
20072   if (!arg2) {
20073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
20074     return 0;
20075   }
20076   {
20077     try {
20078       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
20079     } catch (std::out_of_range& e) {
20080       {
20081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20082       };
20083     } catch (std::exception& e) {
20084       {
20085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20086       };
20087     } catch (...) {
20088       {
20089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20090       };
20091     }
20092   }
20093   jresult = (void *)result;
20094   return jresult;
20095 }
20096
20097
20098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
20099   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
20100   Dali::FilterMode::Type arg2 ;
20101   Dali::FilterMode::Type arg3 ;
20102
20103   arg1 = (Dali::Sampler *)jarg1;
20104   arg2 = (Dali::FilterMode::Type)jarg2;
20105   arg3 = (Dali::FilterMode::Type)jarg3;
20106   {
20107     try {
20108       (arg1)->SetFilterMode(arg2,arg3);
20109     } catch (std::out_of_range& e) {
20110       {
20111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20112       };
20113     } catch (std::exception& e) {
20114       {
20115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20116       };
20117     } catch (...) {
20118       {
20119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20120       };
20121     }
20122   }
20123 }
20124
20125
20126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
20127   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
20128   Dali::WrapMode::Type arg2 ;
20129   Dali::WrapMode::Type arg3 ;
20130
20131   arg1 = (Dali::Sampler *)jarg1;
20132   arg2 = (Dali::WrapMode::Type)jarg2;
20133   arg3 = (Dali::WrapMode::Type)jarg3;
20134   {
20135     try {
20136       (arg1)->SetWrapMode(arg2,arg3);
20137     } catch (std::out_of_range& e) {
20138       {
20139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20140       };
20141     } catch (std::exception& e) {
20142       {
20143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20144       };
20145     } catch (...) {
20146       {
20147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20148       };
20149     }
20150   }
20151 }
20152
20153
20154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
20155   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
20156   Dali::WrapMode::Type arg2 ;
20157   Dali::WrapMode::Type arg3 ;
20158   Dali::WrapMode::Type arg4 ;
20159
20160   arg1 = (Dali::Sampler *)jarg1;
20161   arg2 = (Dali::WrapMode::Type)jarg2;
20162   arg3 = (Dali::WrapMode::Type)jarg3;
20163   arg4 = (Dali::WrapMode::Type)jarg4;
20164   {
20165     try {
20166       (arg1)->SetWrapMode(arg2,arg3,arg4);
20167     } catch (std::out_of_range& e) {
20168       {
20169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20170       };
20171     } catch (std::exception& e) {
20172       {
20173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20174       };
20175     } catch (...) {
20176       {
20177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20178       };
20179     }
20180   }
20181 }
20182
20183
20184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
20185   void * jresult ;
20186   Dali::TextureSet result;
20187
20188   {
20189     try {
20190       result = Dali::TextureSet::New();
20191     } catch (std::out_of_range& e) {
20192       {
20193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20194       };
20195     } catch (std::exception& e) {
20196       {
20197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20198       };
20199     } catch (...) {
20200       {
20201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20202       };
20203     }
20204   }
20205   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
20206   return jresult;
20207 }
20208
20209
20210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
20211   void * jresult ;
20212   Dali::TextureSet *result = 0 ;
20213
20214   {
20215     try {
20216       result = (Dali::TextureSet *)new Dali::TextureSet();
20217     } catch (std::out_of_range& e) {
20218       {
20219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20220       };
20221     } catch (std::exception& e) {
20222       {
20223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20224       };
20225     } catch (...) {
20226       {
20227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20228       };
20229     }
20230   }
20231   jresult = (void *)result;
20232   return jresult;
20233 }
20234
20235
20236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
20237   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
20238
20239   arg1 = (Dali::TextureSet *)jarg1;
20240   {
20241     try {
20242       delete arg1;
20243     } catch (std::out_of_range& e) {
20244       {
20245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20246       };
20247     } catch (std::exception& e) {
20248       {
20249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20250       };
20251     } catch (...) {
20252       {
20253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20254       };
20255     }
20256   }
20257 }
20258
20259
20260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
20261   void * jresult ;
20262   Dali::TextureSet *arg1 = 0 ;
20263   Dali::TextureSet *result = 0 ;
20264
20265   arg1 = (Dali::TextureSet *)jarg1;
20266   if (!arg1) {
20267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
20268     return 0;
20269   }
20270   {
20271     try {
20272       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
20273     } catch (std::out_of_range& e) {
20274       {
20275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20276       };
20277     } catch (std::exception& e) {
20278       {
20279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20280       };
20281     } catch (...) {
20282       {
20283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20284       };
20285     }
20286   }
20287   jresult = (void *)result;
20288   return jresult;
20289 }
20290
20291
20292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
20293   void * jresult ;
20294   Dali::BaseHandle arg1 ;
20295   Dali::BaseHandle *argp1 ;
20296   Dali::TextureSet result;
20297
20298   argp1 = (Dali::BaseHandle *)jarg1;
20299   if (!argp1) {
20300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20301     return 0;
20302   }
20303   arg1 = *argp1;
20304   {
20305     try {
20306       result = Dali::TextureSet::DownCast(arg1);
20307     } catch (std::out_of_range& e) {
20308       {
20309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20310       };
20311     } catch (std::exception& e) {
20312       {
20313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20314       };
20315     } catch (...) {
20316       {
20317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20318       };
20319     }
20320   }
20321   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
20327   void * jresult ;
20328   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
20329   Dali::TextureSet *arg2 = 0 ;
20330   Dali::TextureSet *result = 0 ;
20331
20332   arg1 = (Dali::TextureSet *)jarg1;
20333   arg2 = (Dali::TextureSet *)jarg2;
20334   if (!arg2) {
20335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
20336     return 0;
20337   }
20338   {
20339     try {
20340       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
20341     } catch (std::out_of_range& e) {
20342       {
20343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20344       };
20345     } catch (std::exception& e) {
20346       {
20347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20348       };
20349     } catch (...) {
20350       {
20351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20352       };
20353     }
20354   }
20355   jresult = (void *)result;
20356   return jresult;
20357 }
20358
20359
20360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
20361   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
20362   size_t arg2 ;
20363   Dali::Texture arg3 ;
20364   Dali::Texture *argp3 ;
20365
20366   arg1 = (Dali::TextureSet *)jarg1;
20367   arg2 = (size_t)jarg2;
20368   argp3 = (Dali::Texture *)jarg3;
20369   if (!argp3) {
20370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
20371     return ;
20372   }
20373   arg3 = *argp3;
20374   {
20375     try {
20376       (arg1)->SetTexture(arg2,arg3);
20377     } catch (std::out_of_range& e) {
20378       {
20379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20380       };
20381     } catch (std::exception& e) {
20382       {
20383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20384       };
20385     } catch (...) {
20386       {
20387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20388       };
20389     }
20390   }
20391 }
20392
20393
20394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
20395   void * jresult ;
20396   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
20397   size_t arg2 ;
20398   Dali::Texture result;
20399
20400   arg1 = (Dali::TextureSet *)jarg1;
20401   arg2 = (size_t)jarg2;
20402   {
20403     try {
20404       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
20405     } catch (std::out_of_range& e) {
20406       {
20407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20408       };
20409     } catch (std::exception& e) {
20410       {
20411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20412       };
20413     } catch (...) {
20414       {
20415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20416       };
20417     }
20418   }
20419   jresult = new Dali::Texture((const Dali::Texture &)result);
20420   return jresult;
20421 }
20422
20423
20424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
20425   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
20426   size_t arg2 ;
20427   Dali::Sampler arg3 ;
20428   Dali::Sampler *argp3 ;
20429
20430   arg1 = (Dali::TextureSet *)jarg1;
20431   arg2 = (size_t)jarg2;
20432   argp3 = (Dali::Sampler *)jarg3;
20433   if (!argp3) {
20434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
20435     return ;
20436   }
20437   arg3 = *argp3;
20438   {
20439     try {
20440       (arg1)->SetSampler(arg2,arg3);
20441     } catch (std::out_of_range& e) {
20442       {
20443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20444       };
20445     } catch (std::exception& e) {
20446       {
20447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20448       };
20449     } catch (...) {
20450       {
20451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20452       };
20453     }
20454   }
20455 }
20456
20457
20458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
20459   void * jresult ;
20460   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
20461   size_t arg2 ;
20462   Dali::Sampler result;
20463
20464   arg1 = (Dali::TextureSet *)jarg1;
20465   arg2 = (size_t)jarg2;
20466   {
20467     try {
20468       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
20469     } catch (std::out_of_range& e) {
20470       {
20471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20472       };
20473     } catch (std::exception& e) {
20474       {
20475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20476       };
20477     } catch (...) {
20478       {
20479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20480       };
20481     }
20482   }
20483   jresult = new Dali::Sampler((const Dali::Sampler &)result);
20484   return jresult;
20485 }
20486
20487
20488 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
20489   unsigned long jresult ;
20490   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
20491   size_t result;
20492
20493   arg1 = (Dali::TextureSet *)jarg1;
20494   {
20495     try {
20496       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
20497     } catch (std::out_of_range& e) {
20498       {
20499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20500       };
20501     } catch (std::exception& e) {
20502       {
20503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20504       };
20505     } catch (...) {
20506       {
20507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20508       };
20509     }
20510   }
20511   jresult = (unsigned long)result;
20512   return jresult;
20513 }
20514
20515
20516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
20517   void * jresult ;
20518   Dali::Property::Map *arg1 = 0 ;
20519   Dali::PropertyBuffer result;
20520
20521   arg1 = (Dali::Property::Map *)jarg1;
20522   if (!arg1) {
20523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
20524     return 0;
20525   }
20526   {
20527     try {
20528       result = Dali::PropertyBuffer::New(*arg1);
20529     } catch (std::out_of_range& e) {
20530       {
20531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20532       };
20533     } catch (std::exception& e) {
20534       {
20535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20536       };
20537     } catch (...) {
20538       {
20539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20540       };
20541     }
20542   }
20543   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
20544   return jresult;
20545 }
20546
20547
20548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
20549   void * jresult ;
20550   Dali::PropertyBuffer *result = 0 ;
20551
20552   {
20553     try {
20554       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
20555     } catch (std::out_of_range& e) {
20556       {
20557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20558       };
20559     } catch (std::exception& e) {
20560       {
20561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20562       };
20563     } catch (...) {
20564       {
20565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20566       };
20567     }
20568   }
20569   jresult = (void *)result;
20570   return jresult;
20571 }
20572
20573
20574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
20575   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
20576
20577   arg1 = (Dali::PropertyBuffer *)jarg1;
20578   {
20579     try {
20580       delete arg1;
20581     } catch (std::out_of_range& e) {
20582       {
20583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20584       };
20585     } catch (std::exception& e) {
20586       {
20587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20588       };
20589     } catch (...) {
20590       {
20591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20592       };
20593     }
20594   }
20595 }
20596
20597
20598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
20599   void * jresult ;
20600   Dali::PropertyBuffer *arg1 = 0 ;
20601   Dali::PropertyBuffer *result = 0 ;
20602
20603   arg1 = (Dali::PropertyBuffer *)jarg1;
20604   if (!arg1) {
20605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
20606     return 0;
20607   }
20608   {
20609     try {
20610       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
20611     } catch (std::out_of_range& e) {
20612       {
20613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20614       };
20615     } catch (std::exception& e) {
20616       {
20617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20618       };
20619     } catch (...) {
20620       {
20621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20622       };
20623     }
20624   }
20625   jresult = (void *)result;
20626   return jresult;
20627 }
20628
20629
20630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
20631   void * jresult ;
20632   Dali::BaseHandle arg1 ;
20633   Dali::BaseHandle *argp1 ;
20634   Dali::PropertyBuffer result;
20635
20636   argp1 = (Dali::BaseHandle *)jarg1;
20637   if (!argp1) {
20638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20639     return 0;
20640   }
20641   arg1 = *argp1;
20642   {
20643     try {
20644       result = Dali::PropertyBuffer::DownCast(arg1);
20645     } catch (std::out_of_range& e) {
20646       {
20647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20648       };
20649     } catch (std::exception& e) {
20650       {
20651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20652       };
20653     } catch (...) {
20654       {
20655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20656       };
20657     }
20658   }
20659   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
20660   return jresult;
20661 }
20662
20663
20664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
20665   void * jresult ;
20666   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
20667   Dali::PropertyBuffer *arg2 = 0 ;
20668   Dali::PropertyBuffer *result = 0 ;
20669
20670   arg1 = (Dali::PropertyBuffer *)jarg1;
20671   arg2 = (Dali::PropertyBuffer *)jarg2;
20672   if (!arg2) {
20673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
20674     return 0;
20675   }
20676   {
20677     try {
20678       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
20679     } catch (std::out_of_range& e) {
20680       {
20681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20682       };
20683     } catch (std::exception& e) {
20684       {
20685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20686       };
20687     } catch (...) {
20688       {
20689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20690       };
20691     }
20692   }
20693   jresult = (void *)result;
20694   return jresult;
20695 }
20696
20697
20698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
20699   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
20700   void *arg2 = (void *) 0 ;
20701   std::size_t arg3 ;
20702
20703   arg1 = (Dali::PropertyBuffer *)jarg1;
20704   arg2 = jarg2;
20705   arg3 = (std::size_t)jarg3;
20706   {
20707     try {
20708       (arg1)->SetData((void const *)arg2,arg3);
20709     } catch (std::out_of_range& e) {
20710       {
20711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20712       };
20713     } catch (std::exception& e) {
20714       {
20715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20716       };
20717     } catch (...) {
20718       {
20719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20720       };
20721     }
20722   }
20723 }
20724
20725
20726 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
20727   unsigned long jresult ;
20728   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
20729   std::size_t result;
20730
20731   arg1 = (Dali::PropertyBuffer *)jarg1;
20732   {
20733     try {
20734       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
20735     } catch (std::out_of_range& e) {
20736       {
20737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20738       };
20739     } catch (std::exception& e) {
20740       {
20741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20742       };
20743     } catch (...) {
20744       {
20745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20746       };
20747     }
20748   }
20749   jresult = (unsigned long)result;
20750   return jresult;
20751 }
20752
20753
20754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
20755   void * jresult ;
20756   Dali::Geometry result;
20757
20758   {
20759     try {
20760       result = Dali::Geometry::New();
20761     } catch (std::out_of_range& e) {
20762       {
20763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20764       };
20765     } catch (std::exception& e) {
20766       {
20767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20768       };
20769     } catch (...) {
20770       {
20771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20772       };
20773     }
20774   }
20775   jresult = new Dali::Geometry((const Dali::Geometry &)result);
20776   return jresult;
20777 }
20778
20779
20780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
20781   void * jresult ;
20782   Dali::Geometry *result = 0 ;
20783
20784   {
20785     try {
20786       result = (Dali::Geometry *)new Dali::Geometry();
20787     } catch (std::out_of_range& e) {
20788       {
20789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20790       };
20791     } catch (std::exception& e) {
20792       {
20793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20794       };
20795     } catch (...) {
20796       {
20797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20798       };
20799     }
20800   }
20801   jresult = (void *)result;
20802   return jresult;
20803 }
20804
20805
20806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
20807   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
20808
20809   arg1 = (Dali::Geometry *)jarg1;
20810   {
20811     try {
20812       delete arg1;
20813     } catch (std::out_of_range& e) {
20814       {
20815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20816       };
20817     } catch (std::exception& e) {
20818       {
20819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20820       };
20821     } catch (...) {
20822       {
20823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20824       };
20825     }
20826   }
20827 }
20828
20829
20830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
20831   void * jresult ;
20832   Dali::Geometry *arg1 = 0 ;
20833   Dali::Geometry *result = 0 ;
20834
20835   arg1 = (Dali::Geometry *)jarg1;
20836   if (!arg1) {
20837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
20838     return 0;
20839   }
20840   {
20841     try {
20842       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
20843     } catch (std::out_of_range& e) {
20844       {
20845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20846       };
20847     } catch (std::exception& e) {
20848       {
20849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20850       };
20851     } catch (...) {
20852       {
20853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20854       };
20855     }
20856   }
20857   jresult = (void *)result;
20858   return jresult;
20859 }
20860
20861
20862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
20863   void * jresult ;
20864   Dali::BaseHandle arg1 ;
20865   Dali::BaseHandle *argp1 ;
20866   Dali::Geometry result;
20867
20868   argp1 = (Dali::BaseHandle *)jarg1;
20869   if (!argp1) {
20870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20871     return 0;
20872   }
20873   arg1 = *argp1;
20874   {
20875     try {
20876       result = Dali::Geometry::DownCast(arg1);
20877     } catch (std::out_of_range& e) {
20878       {
20879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20880       };
20881     } catch (std::exception& e) {
20882       {
20883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20884       };
20885     } catch (...) {
20886       {
20887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20888       };
20889     }
20890   }
20891   jresult = new Dali::Geometry((const Dali::Geometry &)result);
20892   return jresult;
20893 }
20894
20895
20896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
20897   void * jresult ;
20898   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
20899   Dali::Geometry *arg2 = 0 ;
20900   Dali::Geometry *result = 0 ;
20901
20902   arg1 = (Dali::Geometry *)jarg1;
20903   arg2 = (Dali::Geometry *)jarg2;
20904   if (!arg2) {
20905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
20906     return 0;
20907   }
20908   {
20909     try {
20910       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
20911     } catch (std::out_of_range& e) {
20912       {
20913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20914       };
20915     } catch (std::exception& e) {
20916       {
20917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20918       };
20919     } catch (...) {
20920       {
20921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20922       };
20923     }
20924   }
20925   jresult = (void *)result;
20926   return jresult;
20927 }
20928
20929
20930 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
20931   unsigned long jresult ;
20932   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
20933   Dali::PropertyBuffer *arg2 = 0 ;
20934   std::size_t result;
20935
20936   arg1 = (Dali::Geometry *)jarg1;
20937   arg2 = (Dali::PropertyBuffer *)jarg2;
20938   if (!arg2) {
20939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
20940     return 0;
20941   }
20942   {
20943     try {
20944       result = (arg1)->AddVertexBuffer(*arg2);
20945     } catch (std::out_of_range& e) {
20946       {
20947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20948       };
20949     } catch (std::exception& e) {
20950       {
20951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20952       };
20953     } catch (...) {
20954       {
20955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20956       };
20957     }
20958   }
20959   jresult = (unsigned long)result;
20960   return jresult;
20961 }
20962
20963
20964 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
20965   unsigned long jresult ;
20966   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
20967   std::size_t result;
20968
20969   arg1 = (Dali::Geometry *)jarg1;
20970   {
20971     try {
20972       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
20973     } catch (std::out_of_range& e) {
20974       {
20975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20976       };
20977     } catch (std::exception& e) {
20978       {
20979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20980       };
20981     } catch (...) {
20982       {
20983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20984       };
20985     }
20986   }
20987   jresult = (unsigned long)result;
20988   return jresult;
20989 }
20990
20991
20992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
20993   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
20994   std::size_t arg2 ;
20995
20996   arg1 = (Dali::Geometry *)jarg1;
20997   arg2 = (std::size_t)jarg2;
20998   {
20999     try {
21000       (arg1)->RemoveVertexBuffer(arg2);
21001     } catch (std::out_of_range& e) {
21002       {
21003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21004       };
21005     } catch (std::exception& e) {
21006       {
21007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21008       };
21009     } catch (...) {
21010       {
21011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21012       };
21013     }
21014   }
21015 }
21016
21017
21018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
21019   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
21020   unsigned short *arg2 = (unsigned short *) 0 ;
21021   size_t arg3 ;
21022
21023   arg1 = (Dali::Geometry *)jarg1;
21024   arg2 = jarg2;
21025   arg3 = (size_t)jarg3;
21026   {
21027     try {
21028       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
21029     } catch (std::out_of_range& e) {
21030       {
21031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21032       };
21033     } catch (std::exception& e) {
21034       {
21035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21036       };
21037     } catch (...) {
21038       {
21039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21040       };
21041     }
21042   }
21043
21044
21045 }
21046
21047
21048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
21049   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
21050   Dali::Geometry::Type arg2 ;
21051
21052   arg1 = (Dali::Geometry *)jarg1;
21053   arg2 = (Dali::Geometry::Type)jarg2;
21054   {
21055     try {
21056       (arg1)->SetType(arg2);
21057     } catch (std::out_of_range& e) {
21058       {
21059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21060       };
21061     } catch (std::exception& e) {
21062       {
21063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21064       };
21065     } catch (...) {
21066       {
21067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21068       };
21069     }
21070   }
21071 }
21072
21073
21074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
21075   int jresult ;
21076   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
21077   Dali::Geometry::Type result;
21078
21079   arg1 = (Dali::Geometry *)jarg1;
21080   {
21081     try {
21082       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
21083     } catch (std::out_of_range& e) {
21084       {
21085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21086       };
21087     } catch (std::exception& e) {
21088       {
21089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21090       };
21091     } catch (...) {
21092       {
21093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21094       };
21095     }
21096   }
21097   jresult = (int)result;
21098   return jresult;
21099 }
21100
21101
21102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
21103   void * jresult ;
21104   Dali::Shader::Hint *result = 0 ;
21105
21106   {
21107     try {
21108       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
21109     } catch (std::out_of_range& e) {
21110       {
21111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21112       };
21113     } catch (std::exception& e) {
21114       {
21115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21116       };
21117     } catch (...) {
21118       {
21119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21120       };
21121     }
21122   }
21123   jresult = (void *)result;
21124   return jresult;
21125 }
21126
21127
21128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
21129   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
21130
21131   arg1 = (Dali::Shader::Hint *)jarg1;
21132   {
21133     try {
21134       delete arg1;
21135     } catch (std::out_of_range& e) {
21136       {
21137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21138       };
21139     } catch (std::exception& e) {
21140       {
21141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21142       };
21143     } catch (...) {
21144       {
21145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21146       };
21147     }
21148   }
21149 }
21150
21151
21152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
21153   int jresult ;
21154   int result;
21155
21156   result = (int)Dali::Shader::Property::PROGRAM;
21157   jresult = (int)result;
21158   return jresult;
21159 }
21160
21161
21162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
21163   void * jresult ;
21164   Dali::Shader::Property *result = 0 ;
21165
21166   {
21167     try {
21168       result = (Dali::Shader::Property *)new Dali::Shader::Property();
21169     } catch (std::out_of_range& e) {
21170       {
21171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21172       };
21173     } catch (std::exception& e) {
21174       {
21175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21176       };
21177     } catch (...) {
21178       {
21179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21180       };
21181     }
21182   }
21183   jresult = (void *)result;
21184   return jresult;
21185 }
21186
21187
21188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
21189   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
21190
21191   arg1 = (Dali::Shader::Property *)jarg1;
21192   {
21193     try {
21194       delete arg1;
21195     } catch (std::out_of_range& e) {
21196       {
21197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21198       };
21199     } catch (std::exception& e) {
21200       {
21201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21202       };
21203     } catch (...) {
21204       {
21205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21206       };
21207     }
21208   }
21209 }
21210
21211
21212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
21213   void * jresult ;
21214   std::string *arg1 = 0 ;
21215   std::string *arg2 = 0 ;
21216   Dali::Shader::Hint::Value arg3 ;
21217   Dali::Shader result;
21218
21219   if (!jarg1) {
21220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21221     return 0;
21222   }
21223   std::string arg1_str(jarg1);
21224   arg1 = &arg1_str;
21225   if (!jarg2) {
21226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21227     return 0;
21228   }
21229   std::string arg2_str(jarg2);
21230   arg2 = &arg2_str;
21231   arg3 = (Dali::Shader::Hint::Value)jarg3;
21232   {
21233     try {
21234       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
21235     } catch (std::out_of_range& e) {
21236       {
21237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21238       };
21239     } catch (std::exception& e) {
21240       {
21241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21242       };
21243     } catch (...) {
21244       {
21245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21246       };
21247     }
21248   }
21249   jresult = new Dali::Shader((const Dali::Shader &)result);
21250
21251   //argout typemap for const std::string&
21252
21253
21254   //argout typemap for const std::string&
21255
21256   return jresult;
21257 }
21258
21259
21260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
21261   void * jresult ;
21262   std::string *arg1 = 0 ;
21263   std::string *arg2 = 0 ;
21264   Dali::Shader result;
21265
21266   if (!jarg1) {
21267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21268     return 0;
21269   }
21270   std::string arg1_str(jarg1);
21271   arg1 = &arg1_str;
21272   if (!jarg2) {
21273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21274     return 0;
21275   }
21276   std::string arg2_str(jarg2);
21277   arg2 = &arg2_str;
21278   {
21279     try {
21280       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
21281     } catch (std::out_of_range& e) {
21282       {
21283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21284       };
21285     } catch (std::exception& e) {
21286       {
21287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21288       };
21289     } catch (...) {
21290       {
21291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21292       };
21293     }
21294   }
21295   jresult = new Dali::Shader((const Dali::Shader &)result);
21296
21297   //argout typemap for const std::string&
21298
21299
21300   //argout typemap for const std::string&
21301
21302   return jresult;
21303 }
21304
21305
21306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
21307   void * jresult ;
21308   Dali::Shader *result = 0 ;
21309
21310   {
21311     try {
21312       result = (Dali::Shader *)new Dali::Shader();
21313     } catch (std::out_of_range& e) {
21314       {
21315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21316       };
21317     } catch (std::exception& e) {
21318       {
21319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21320       };
21321     } catch (...) {
21322       {
21323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21324       };
21325     }
21326   }
21327   jresult = (void *)result;
21328   return jresult;
21329 }
21330
21331
21332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
21333   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
21334
21335   arg1 = (Dali::Shader *)jarg1;
21336   {
21337     try {
21338       delete arg1;
21339     } catch (std::out_of_range& e) {
21340       {
21341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21342       };
21343     } catch (std::exception& e) {
21344       {
21345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21346       };
21347     } catch (...) {
21348       {
21349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21350       };
21351     }
21352   }
21353 }
21354
21355
21356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
21357   void * jresult ;
21358   Dali::Shader *arg1 = 0 ;
21359   Dali::Shader *result = 0 ;
21360
21361   arg1 = (Dali::Shader *)jarg1;
21362   if (!arg1) {
21363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
21364     return 0;
21365   }
21366   {
21367     try {
21368       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
21369     } catch (std::out_of_range& e) {
21370       {
21371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21372       };
21373     } catch (std::exception& e) {
21374       {
21375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21376       };
21377     } catch (...) {
21378       {
21379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21380       };
21381     }
21382   }
21383   jresult = (void *)result;
21384   return jresult;
21385 }
21386
21387
21388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
21389   void * jresult ;
21390   Dali::BaseHandle arg1 ;
21391   Dali::BaseHandle *argp1 ;
21392   Dali::Shader result;
21393
21394   argp1 = (Dali::BaseHandle *)jarg1;
21395   if (!argp1) {
21396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21397     return 0;
21398   }
21399   arg1 = *argp1;
21400   {
21401     try {
21402       result = Dali::Shader::DownCast(arg1);
21403     } catch (std::out_of_range& e) {
21404       {
21405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21406       };
21407     } catch (std::exception& e) {
21408       {
21409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21410       };
21411     } catch (...) {
21412       {
21413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21414       };
21415     }
21416   }
21417   jresult = new Dali::Shader((const Dali::Shader &)result);
21418   return jresult;
21419 }
21420
21421
21422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
21423   void * jresult ;
21424   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
21425   Dali::Shader *arg2 = 0 ;
21426   Dali::Shader *result = 0 ;
21427
21428   arg1 = (Dali::Shader *)jarg1;
21429   arg2 = (Dali::Shader *)jarg2;
21430   if (!arg2) {
21431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
21432     return 0;
21433   }
21434   {
21435     try {
21436       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
21437     } catch (std::out_of_range& e) {
21438       {
21439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21440       };
21441     } catch (std::exception& e) {
21442       {
21443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21444       };
21445     } catch (...) {
21446       {
21447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21448       };
21449     }
21450   }
21451   jresult = (void *)result;
21452   return jresult;
21453 }
21454
21455
21456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
21457   int jresult ;
21458   int result;
21459
21460   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
21461   jresult = (int)result;
21462   return jresult;
21463 }
21464
21465
21466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
21467   int jresult ;
21468   int result;
21469
21470   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
21471   jresult = (int)result;
21472   return jresult;
21473 }
21474
21475
21476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
21477   int jresult ;
21478   int result;
21479
21480   result = (int)Dali::Renderer::Property::BLEND_MODE;
21481   jresult = (int)result;
21482   return jresult;
21483 }
21484
21485
21486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
21487   int jresult ;
21488   int result;
21489
21490   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
21491   jresult = (int)result;
21492   return jresult;
21493 }
21494
21495
21496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
21497   int jresult ;
21498   int result;
21499
21500   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
21501   jresult = (int)result;
21502   return jresult;
21503 }
21504
21505
21506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
21507   int jresult ;
21508   int result;
21509
21510   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
21511   jresult = (int)result;
21512   return jresult;
21513 }
21514
21515
21516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
21517   int jresult ;
21518   int result;
21519
21520   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
21521   jresult = (int)result;
21522   return jresult;
21523 }
21524
21525
21526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
21527   int jresult ;
21528   int result;
21529
21530   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
21531   jresult = (int)result;
21532   return jresult;
21533 }
21534
21535
21536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
21537   int jresult ;
21538   int result;
21539
21540   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
21541   jresult = (int)result;
21542   return jresult;
21543 }
21544
21545
21546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
21547   int jresult ;
21548   int result;
21549
21550   result = (int)Dali::Renderer::Property::BLEND_COLOR;
21551   jresult = (int)result;
21552   return jresult;
21553 }
21554
21555
21556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
21557   int jresult ;
21558   int result;
21559
21560   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
21561   jresult = (int)result;
21562   return jresult;
21563 }
21564
21565
21566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
21567   int jresult ;
21568   int result;
21569
21570   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
21571   jresult = (int)result;
21572   return jresult;
21573 }
21574
21575
21576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
21577   int jresult ;
21578   int result;
21579
21580   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
21581   jresult = (int)result;
21582   return jresult;
21583 }
21584
21585
21586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
21587   int jresult ;
21588   int result;
21589
21590   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
21591   jresult = (int)result;
21592   return jresult;
21593 }
21594
21595
21596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
21597   int jresult ;
21598   int result;
21599
21600   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
21601   jresult = (int)result;
21602   return jresult;
21603 }
21604
21605
21606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
21607   int jresult ;
21608   int result;
21609
21610   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
21611   jresult = (int)result;
21612   return jresult;
21613 }
21614
21615
21616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
21617   int jresult ;
21618   int result;
21619
21620   result = (int)Dali::Renderer::Property::RENDER_MODE;
21621   jresult = (int)result;
21622   return jresult;
21623 }
21624
21625
21626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
21627   int jresult ;
21628   int result;
21629
21630   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
21631   jresult = (int)result;
21632   return jresult;
21633 }
21634
21635
21636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
21637   int jresult ;
21638   int result;
21639
21640   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
21641   jresult = (int)result;
21642   return jresult;
21643 }
21644
21645
21646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
21647   int jresult ;
21648   int result;
21649
21650   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
21651   jresult = (int)result;
21652   return jresult;
21653 }
21654
21655
21656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
21657   int jresult ;
21658   int result;
21659
21660   result = (int)Dali::Renderer::Property::STENCIL_MASK;
21661   jresult = (int)result;
21662   return jresult;
21663 }
21664
21665
21666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
21667   int jresult ;
21668   int result;
21669
21670   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
21671   jresult = (int)result;
21672   return jresult;
21673 }
21674
21675
21676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
21677   int jresult ;
21678   int result;
21679
21680   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
21681   jresult = (int)result;
21682   return jresult;
21683 }
21684
21685
21686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
21687   int jresult ;
21688   int result;
21689
21690   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
21691   jresult = (int)result;
21692   return jresult;
21693 }
21694
21695
21696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BATCHING_ENABLED_get() {
21697   int jresult ;
21698   int result;
21699
21700   result = (int)Dali::Renderer::Property::BATCHING_ENABLED;
21701   jresult = (int)result;
21702   return jresult;
21703 }
21704
21705
21706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
21707   void * jresult ;
21708   Dali::Renderer::Property *result = 0 ;
21709
21710   {
21711     try {
21712       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
21713     } catch (std::out_of_range& e) {
21714       {
21715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21716       };
21717     } catch (std::exception& e) {
21718       {
21719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21720       };
21721     } catch (...) {
21722       {
21723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21724       };
21725     }
21726   }
21727   jresult = (void *)result;
21728   return jresult;
21729 }
21730
21731
21732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
21733   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
21734
21735   arg1 = (Dali::Renderer::Property *)jarg1;
21736   {
21737     try {
21738       delete arg1;
21739     } catch (std::out_of_range& e) {
21740       {
21741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21742       };
21743     } catch (std::exception& e) {
21744       {
21745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21746       };
21747     } catch (...) {
21748       {
21749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21750       };
21751     }
21752   }
21753 }
21754
21755
21756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
21757   void * jresult ;
21758   Dali::Geometry *arg1 = 0 ;
21759   Dali::Shader *arg2 = 0 ;
21760   Dali::Renderer result;
21761
21762   arg1 = (Dali::Geometry *)jarg1;
21763   if (!arg1) {
21764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
21765     return 0;
21766   }
21767   arg2 = (Dali::Shader *)jarg2;
21768   if (!arg2) {
21769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
21770     return 0;
21771   }
21772   {
21773     try {
21774       result = Dali::Renderer::New(*arg1,*arg2);
21775     } catch (std::out_of_range& e) {
21776       {
21777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21778       };
21779     } catch (std::exception& e) {
21780       {
21781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21782       };
21783     } catch (...) {
21784       {
21785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21786       };
21787     }
21788   }
21789   jresult = new Dali::Renderer((const Dali::Renderer &)result);
21790   return jresult;
21791 }
21792
21793
21794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
21795   void * jresult ;
21796   Dali::Renderer *result = 0 ;
21797
21798   {
21799     try {
21800       result = (Dali::Renderer *)new Dali::Renderer();
21801     } catch (std::out_of_range& e) {
21802       {
21803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21804       };
21805     } catch (std::exception& e) {
21806       {
21807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21808       };
21809     } catch (...) {
21810       {
21811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21812       };
21813     }
21814   }
21815   jresult = (void *)result;
21816   return jresult;
21817 }
21818
21819
21820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
21821   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
21822
21823   arg1 = (Dali::Renderer *)jarg1;
21824   {
21825     try {
21826       delete arg1;
21827     } catch (std::out_of_range& e) {
21828       {
21829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21830       };
21831     } catch (std::exception& e) {
21832       {
21833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21834       };
21835     } catch (...) {
21836       {
21837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21838       };
21839     }
21840   }
21841 }
21842
21843
21844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
21845   void * jresult ;
21846   Dali::Renderer *arg1 = 0 ;
21847   Dali::Renderer *result = 0 ;
21848
21849   arg1 = (Dali::Renderer *)jarg1;
21850   if (!arg1) {
21851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
21852     return 0;
21853   }
21854   {
21855     try {
21856       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
21857     } catch (std::out_of_range& e) {
21858       {
21859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21860       };
21861     } catch (std::exception& e) {
21862       {
21863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21864       };
21865     } catch (...) {
21866       {
21867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21868       };
21869     }
21870   }
21871   jresult = (void *)result;
21872   return jresult;
21873 }
21874
21875
21876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
21877   void * jresult ;
21878   Dali::BaseHandle arg1 ;
21879   Dali::BaseHandle *argp1 ;
21880   Dali::Renderer result;
21881
21882   argp1 = (Dali::BaseHandle *)jarg1;
21883   if (!argp1) {
21884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21885     return 0;
21886   }
21887   arg1 = *argp1;
21888   {
21889     try {
21890       result = Dali::Renderer::DownCast(arg1);
21891     } catch (std::out_of_range& e) {
21892       {
21893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21894       };
21895     } catch (std::exception& e) {
21896       {
21897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21898       };
21899     } catch (...) {
21900       {
21901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21902       };
21903     }
21904   }
21905   jresult = new Dali::Renderer((const Dali::Renderer &)result);
21906   return jresult;
21907 }
21908
21909
21910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
21911   void * jresult ;
21912   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
21913   Dali::Renderer *arg2 = 0 ;
21914   Dali::Renderer *result = 0 ;
21915
21916   arg1 = (Dali::Renderer *)jarg1;
21917   arg2 = (Dali::Renderer *)jarg2;
21918   if (!arg2) {
21919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
21920     return 0;
21921   }
21922   {
21923     try {
21924       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
21925     } catch (std::out_of_range& e) {
21926       {
21927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21928       };
21929     } catch (std::exception& e) {
21930       {
21931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21932       };
21933     } catch (...) {
21934       {
21935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21936       };
21937     }
21938   }
21939   jresult = (void *)result;
21940   return jresult;
21941 }
21942
21943
21944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
21945   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
21946   Dali::Geometry *arg2 = 0 ;
21947
21948   arg1 = (Dali::Renderer *)jarg1;
21949   arg2 = (Dali::Geometry *)jarg2;
21950   if (!arg2) {
21951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
21952     return ;
21953   }
21954   {
21955     try {
21956       (arg1)->SetGeometry(*arg2);
21957     } catch (std::out_of_range& e) {
21958       {
21959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21960       };
21961     } catch (std::exception& e) {
21962       {
21963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21964       };
21965     } catch (...) {
21966       {
21967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21968       };
21969     }
21970   }
21971 }
21972
21973
21974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
21975   void * jresult ;
21976   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
21977   Dali::Geometry result;
21978
21979   arg1 = (Dali::Renderer *)jarg1;
21980   {
21981     try {
21982       result = ((Dali::Renderer const *)arg1)->GetGeometry();
21983     } catch (std::out_of_range& e) {
21984       {
21985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21986       };
21987     } catch (std::exception& e) {
21988       {
21989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21990       };
21991     } catch (...) {
21992       {
21993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21994       };
21995     }
21996   }
21997   jresult = new Dali::Geometry((const Dali::Geometry &)result);
21998   return jresult;
21999 }
22000
22001
22002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
22003   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
22004   int arg2 ;
22005   int arg3 ;
22006
22007   arg1 = (Dali::Renderer *)jarg1;
22008   arg2 = (int)jarg2;
22009   arg3 = (int)jarg3;
22010   {
22011     try {
22012       (arg1)->SetIndexRange(arg2,arg3);
22013     } catch (std::out_of_range& e) {
22014       {
22015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22016       };
22017     } catch (std::exception& e) {
22018       {
22019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22020       };
22021     } catch (...) {
22022       {
22023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22024       };
22025     }
22026   }
22027 }
22028
22029
22030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
22031   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
22032   Dali::TextureSet *arg2 = 0 ;
22033
22034   arg1 = (Dali::Renderer *)jarg1;
22035   arg2 = (Dali::TextureSet *)jarg2;
22036   if (!arg2) {
22037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
22038     return ;
22039   }
22040   {
22041     try {
22042       (arg1)->SetTextures(*arg2);
22043     } catch (std::out_of_range& e) {
22044       {
22045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22046       };
22047     } catch (std::exception& e) {
22048       {
22049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22050       };
22051     } catch (...) {
22052       {
22053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22054       };
22055     }
22056   }
22057 }
22058
22059
22060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
22061   void * jresult ;
22062   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
22063   Dali::TextureSet result;
22064
22065   arg1 = (Dali::Renderer *)jarg1;
22066   {
22067     try {
22068       result = ((Dali::Renderer const *)arg1)->GetTextures();
22069     } catch (std::out_of_range& e) {
22070       {
22071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22072       };
22073     } catch (std::exception& e) {
22074       {
22075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22076       };
22077     } catch (...) {
22078       {
22079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22080       };
22081     }
22082   }
22083   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22084   return jresult;
22085 }
22086
22087
22088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
22089   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
22090   Dali::Shader *arg2 = 0 ;
22091
22092   arg1 = (Dali::Renderer *)jarg1;
22093   arg2 = (Dali::Shader *)jarg2;
22094   if (!arg2) {
22095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
22096     return ;
22097   }
22098   {
22099     try {
22100       (arg1)->SetShader(*arg2);
22101     } catch (std::out_of_range& e) {
22102       {
22103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22104       };
22105     } catch (std::exception& e) {
22106       {
22107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22108       };
22109     } catch (...) {
22110       {
22111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22112       };
22113     }
22114   }
22115 }
22116
22117
22118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
22119   void * jresult ;
22120   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
22121   Dali::Shader result;
22122
22123   arg1 = (Dali::Renderer *)jarg1;
22124   {
22125     try {
22126       result = ((Dali::Renderer const *)arg1)->GetShader();
22127     } catch (std::out_of_range& e) {
22128       {
22129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22130       };
22131     } catch (std::exception& e) {
22132       {
22133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22134       };
22135     } catch (...) {
22136       {
22137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22138       };
22139     }
22140   }
22141   jresult = new Dali::Shader((const Dali::Shader &)result);
22142   return jresult;
22143 }
22144
22145
22146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
22147   void * jresult ;
22148   Dali::FrameBuffer::Attachment *result = 0 ;
22149
22150   {
22151     try {
22152       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
22153     } catch (std::out_of_range& e) {
22154       {
22155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22156       };
22157     } catch (std::exception& e) {
22158       {
22159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22160       };
22161     } catch (...) {
22162       {
22163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22164       };
22165     }
22166   }
22167   jresult = (void *)result;
22168   return jresult;
22169 }
22170
22171
22172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
22173   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
22174
22175   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
22176   {
22177     try {
22178       delete arg1;
22179     } catch (std::out_of_range& e) {
22180       {
22181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22182       };
22183     } catch (std::exception& e) {
22184       {
22185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22186       };
22187     } catch (...) {
22188       {
22189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22190       };
22191     }
22192   }
22193 }
22194
22195
22196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
22197   void * jresult ;
22198   unsigned int arg1 ;
22199   unsigned int arg2 ;
22200   unsigned int arg3 ;
22201   Dali::FrameBuffer result;
22202
22203   arg1 = (unsigned int)jarg1;
22204   arg2 = (unsigned int)jarg2;
22205   arg3 = (unsigned int)jarg3;
22206   {
22207     try {
22208       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
22209     } catch (std::out_of_range& e) {
22210       {
22211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22212       };
22213     } catch (std::exception& e) {
22214       {
22215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22216       };
22217     } catch (...) {
22218       {
22219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22220       };
22221     }
22222   }
22223   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
22224   return jresult;
22225 }
22226
22227
22228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
22229   void * jresult ;
22230   Dali::FrameBuffer *result = 0 ;
22231
22232   {
22233     try {
22234       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
22235     } catch (std::out_of_range& e) {
22236       {
22237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22238       };
22239     } catch (std::exception& e) {
22240       {
22241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22242       };
22243     } catch (...) {
22244       {
22245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22246       };
22247     }
22248   }
22249   jresult = (void *)result;
22250   return jresult;
22251 }
22252
22253
22254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
22255   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
22256
22257   arg1 = (Dali::FrameBuffer *)jarg1;
22258   {
22259     try {
22260       delete arg1;
22261     } catch (std::out_of_range& e) {
22262       {
22263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22264       };
22265     } catch (std::exception& e) {
22266       {
22267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22268       };
22269     } catch (...) {
22270       {
22271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22272       };
22273     }
22274   }
22275 }
22276
22277
22278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
22279   void * jresult ;
22280   Dali::FrameBuffer *arg1 = 0 ;
22281   Dali::FrameBuffer *result = 0 ;
22282
22283   arg1 = (Dali::FrameBuffer *)jarg1;
22284   if (!arg1) {
22285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
22286     return 0;
22287   }
22288   {
22289     try {
22290       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
22291     } catch (std::out_of_range& e) {
22292       {
22293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22294       };
22295     } catch (std::exception& e) {
22296       {
22297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22298       };
22299     } catch (...) {
22300       {
22301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22302       };
22303     }
22304   }
22305   jresult = (void *)result;
22306   return jresult;
22307 }
22308
22309
22310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
22311   void * jresult ;
22312   Dali::BaseHandle arg1 ;
22313   Dali::BaseHandle *argp1 ;
22314   Dali::FrameBuffer result;
22315
22316   argp1 = (Dali::BaseHandle *)jarg1;
22317   if (!argp1) {
22318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22319     return 0;
22320   }
22321   arg1 = *argp1;
22322   {
22323     try {
22324       result = Dali::FrameBuffer::DownCast(arg1);
22325     } catch (std::out_of_range& e) {
22326       {
22327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22328       };
22329     } catch (std::exception& e) {
22330       {
22331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22332       };
22333     } catch (...) {
22334       {
22335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22336       };
22337     }
22338   }
22339   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
22340   return jresult;
22341 }
22342
22343
22344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
22345   void * jresult ;
22346   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
22347   Dali::FrameBuffer *arg2 = 0 ;
22348   Dali::FrameBuffer *result = 0 ;
22349
22350   arg1 = (Dali::FrameBuffer *)jarg1;
22351   arg2 = (Dali::FrameBuffer *)jarg2;
22352   if (!arg2) {
22353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
22354     return 0;
22355   }
22356   {
22357     try {
22358       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
22359     } catch (std::out_of_range& e) {
22360       {
22361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22362       };
22363     } catch (std::exception& e) {
22364       {
22365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22366       };
22367     } catch (...) {
22368       {
22369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22370       };
22371     }
22372   }
22373   jresult = (void *)result;
22374   return jresult;
22375 }
22376
22377
22378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
22379   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
22380   Dali::Texture *arg2 = 0 ;
22381
22382   arg1 = (Dali::FrameBuffer *)jarg1;
22383   arg2 = (Dali::Texture *)jarg2;
22384   if (!arg2) {
22385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
22386     return ;
22387   }
22388   {
22389     try {
22390       (arg1)->AttachColorTexture(*arg2);
22391     } catch (std::out_of_range& e) {
22392       {
22393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22394       };
22395     } catch (std::exception& e) {
22396       {
22397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22398       };
22399     } catch (...) {
22400       {
22401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22402       };
22403     }
22404   }
22405 }
22406
22407
22408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
22409   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
22410   Dali::Texture *arg2 = 0 ;
22411   unsigned int arg3 ;
22412   unsigned int arg4 ;
22413
22414   arg1 = (Dali::FrameBuffer *)jarg1;
22415   arg2 = (Dali::Texture *)jarg2;
22416   if (!arg2) {
22417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
22418     return ;
22419   }
22420   arg3 = (unsigned int)jarg3;
22421   arg4 = (unsigned int)jarg4;
22422   {
22423     try {
22424       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
22425     } catch (std::out_of_range& e) {
22426       {
22427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22428       };
22429     } catch (std::exception& e) {
22430       {
22431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22432       };
22433     } catch (...) {
22434       {
22435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22436       };
22437     }
22438   }
22439 }
22440
22441
22442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
22443   void * jresult ;
22444   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
22445   Dali::Texture result;
22446
22447   arg1 = (Dali::FrameBuffer *)jarg1;
22448   {
22449     try {
22450       result = (arg1)->GetColorTexture();
22451     } catch (std::out_of_range& e) {
22452       {
22453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22454       };
22455     } catch (std::exception& e) {
22456       {
22457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22458       };
22459     } catch (...) {
22460       {
22461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22462       };
22463     }
22464   }
22465   jresult = new Dali::Texture((const Dali::Texture &)result);
22466   return jresult;
22467 }
22468
22469
22470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
22471   void * jresult ;
22472   Dali::RenderTaskList *result = 0 ;
22473
22474   {
22475     try {
22476       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
22477     } catch (std::out_of_range& e) {
22478       {
22479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22480       };
22481     } catch (std::exception& e) {
22482       {
22483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22484       };
22485     } catch (...) {
22486       {
22487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22488       };
22489     }
22490   }
22491   jresult = (void *)result;
22492   return jresult;
22493 }
22494
22495
22496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
22497   void * jresult ;
22498   Dali::BaseHandle arg1 ;
22499   Dali::BaseHandle *argp1 ;
22500   Dali::RenderTaskList result;
22501
22502   argp1 = (Dali::BaseHandle *)jarg1;
22503   if (!argp1) {
22504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22505     return 0;
22506   }
22507   arg1 = *argp1;
22508   {
22509     try {
22510       result = Dali::RenderTaskList::DownCast(arg1);
22511     } catch (std::out_of_range& e) {
22512       {
22513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22514       };
22515     } catch (std::exception& e) {
22516       {
22517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22518       };
22519     } catch (...) {
22520       {
22521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22522       };
22523     }
22524   }
22525   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
22526   return jresult;
22527 }
22528
22529
22530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
22531   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
22532
22533   arg1 = (Dali::RenderTaskList *)jarg1;
22534   {
22535     try {
22536       delete arg1;
22537     } catch (std::out_of_range& e) {
22538       {
22539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22540       };
22541     } catch (std::exception& e) {
22542       {
22543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22544       };
22545     } catch (...) {
22546       {
22547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22548       };
22549     }
22550   }
22551 }
22552
22553
22554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
22555   void * jresult ;
22556   Dali::RenderTaskList *arg1 = 0 ;
22557   Dali::RenderTaskList *result = 0 ;
22558
22559   arg1 = (Dali::RenderTaskList *)jarg1;
22560   if (!arg1) {
22561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
22562     return 0;
22563   }
22564   {
22565     try {
22566       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
22567     } catch (std::out_of_range& e) {
22568       {
22569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22570       };
22571     } catch (std::exception& e) {
22572       {
22573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22574       };
22575     } catch (...) {
22576       {
22577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22578       };
22579     }
22580   }
22581   jresult = (void *)result;
22582   return jresult;
22583 }
22584
22585
22586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
22587   void * jresult ;
22588   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
22589   Dali::RenderTaskList *arg2 = 0 ;
22590   Dali::RenderTaskList *result = 0 ;
22591
22592   arg1 = (Dali::RenderTaskList *)jarg1;
22593   arg2 = (Dali::RenderTaskList *)jarg2;
22594   if (!arg2) {
22595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
22596     return 0;
22597   }
22598   {
22599     try {
22600       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
22601     } catch (std::out_of_range& e) {
22602       {
22603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22604       };
22605     } catch (std::exception& e) {
22606       {
22607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22608       };
22609     } catch (...) {
22610       {
22611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22612       };
22613     }
22614   }
22615   jresult = (void *)result;
22616   return jresult;
22617 }
22618
22619
22620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
22621   void * jresult ;
22622   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
22623   Dali::RenderTask result;
22624
22625   arg1 = (Dali::RenderTaskList *)jarg1;
22626   {
22627     try {
22628       result = (arg1)->CreateTask();
22629     } catch (std::out_of_range& e) {
22630       {
22631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22632       };
22633     } catch (std::exception& e) {
22634       {
22635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22636       };
22637     } catch (...) {
22638       {
22639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22640       };
22641     }
22642   }
22643   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
22644   return jresult;
22645 }
22646
22647
22648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
22649   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
22650   Dali::RenderTask arg2 ;
22651   Dali::RenderTask *argp2 ;
22652
22653   arg1 = (Dali::RenderTaskList *)jarg1;
22654   argp2 = (Dali::RenderTask *)jarg2;
22655   if (!argp2) {
22656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
22657     return ;
22658   }
22659   arg2 = *argp2;
22660   {
22661     try {
22662       (arg1)->RemoveTask(arg2);
22663     } catch (std::out_of_range& e) {
22664       {
22665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22666       };
22667     } catch (std::exception& e) {
22668       {
22669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22670       };
22671     } catch (...) {
22672       {
22673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22674       };
22675     }
22676   }
22677 }
22678
22679
22680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
22681   unsigned int jresult ;
22682   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
22683   unsigned int result;
22684
22685   arg1 = (Dali::RenderTaskList *)jarg1;
22686   {
22687     try {
22688       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
22689     } catch (std::out_of_range& e) {
22690       {
22691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22692       };
22693     } catch (std::exception& e) {
22694       {
22695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22696       };
22697     } catch (...) {
22698       {
22699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22700       };
22701     }
22702   }
22703   jresult = result;
22704   return jresult;
22705 }
22706
22707
22708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
22709   void * jresult ;
22710   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
22711   unsigned int arg2 ;
22712   Dali::RenderTask result;
22713
22714   arg1 = (Dali::RenderTaskList *)jarg1;
22715   arg2 = (unsigned int)jarg2;
22716   {
22717     try {
22718       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
22719     } catch (std::out_of_range& e) {
22720       {
22721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22722       };
22723     } catch (std::exception& e) {
22724       {
22725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22726       };
22727     } catch (...) {
22728       {
22729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22730       };
22731     }
22732   }
22733   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
22734   return jresult;
22735 }
22736
22737
22738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
22739   int jresult ;
22740   int result;
22741
22742   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
22743   jresult = (int)result;
22744   return jresult;
22745 }
22746
22747
22748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
22749   int jresult ;
22750   int result;
22751
22752   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
22753   jresult = (int)result;
22754   return jresult;
22755 }
22756
22757
22758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
22759   int jresult ;
22760   int result;
22761
22762   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
22763   jresult = (int)result;
22764   return jresult;
22765 }
22766
22767
22768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
22769   int jresult ;
22770   int result;
22771
22772   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
22773   jresult = (int)result;
22774   return jresult;
22775 }
22776
22777
22778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
22779   void * jresult ;
22780   Dali::RenderTask::Property *result = 0 ;
22781
22782   {
22783     try {
22784       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
22785     } catch (std::out_of_range& e) {
22786       {
22787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22788       };
22789     } catch (std::exception& e) {
22790       {
22791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22792       };
22793     } catch (...) {
22794       {
22795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22796       };
22797     }
22798   }
22799   jresult = (void *)result;
22800   return jresult;
22801 }
22802
22803
22804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
22805   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
22806
22807   arg1 = (Dali::RenderTask::Property *)jarg1;
22808   {
22809     try {
22810       delete arg1;
22811     } catch (std::out_of_range& e) {
22812       {
22813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22814       };
22815     } catch (std::exception& e) {
22816       {
22817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22818       };
22819     } catch (...) {
22820       {
22821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22822       };
22823     }
22824   }
22825 }
22826
22827
22828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
22829   void * jresult ;
22830   bool (*result)(Dali::Vector2 &) = 0 ;
22831
22832   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
22833   jresult = (void *)result;
22834   return jresult;
22835 }
22836
22837
22838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
22839   void * jresult ;
22840   bool (*result)(Dali::Vector2 &) = 0 ;
22841
22842   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
22843   jresult = (void *)result;
22844   return jresult;
22845 }
22846
22847
22848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
22849   unsigned int jresult ;
22850   bool result;
22851
22852   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
22853   jresult = result;
22854   return jresult;
22855 }
22856
22857
22858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
22859   unsigned int jresult ;
22860   bool result;
22861
22862   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
22863   jresult = result;
22864   return jresult;
22865 }
22866
22867
22868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
22869   void * jresult ;
22870   Dali::Vector4 *result = 0 ;
22871
22872   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
22873   jresult = (void *)result;
22874   return jresult;
22875 }
22876
22877
22878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
22879   unsigned int jresult ;
22880   bool result;
22881
22882   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
22883   jresult = result;
22884   return jresult;
22885 }
22886
22887
22888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
22889   unsigned int jresult ;
22890   bool result;
22891
22892   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
22893   jresult = result;
22894   return jresult;
22895 }
22896
22897
22898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
22899   unsigned int jresult ;
22900   unsigned int result;
22901
22902   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
22903   jresult = result;
22904   return jresult;
22905 }
22906
22907
22908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
22909   void * jresult ;
22910   Dali::RenderTask *result = 0 ;
22911
22912   {
22913     try {
22914       result = (Dali::RenderTask *)new Dali::RenderTask();
22915     } catch (std::out_of_range& e) {
22916       {
22917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22918       };
22919     } catch (std::exception& e) {
22920       {
22921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22922       };
22923     } catch (...) {
22924       {
22925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22926       };
22927     }
22928   }
22929   jresult = (void *)result;
22930   return jresult;
22931 }
22932
22933
22934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
22935   void * jresult ;
22936   Dali::BaseHandle arg1 ;
22937   Dali::BaseHandle *argp1 ;
22938   Dali::RenderTask result;
22939
22940   argp1 = (Dali::BaseHandle *)jarg1;
22941   if (!argp1) {
22942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22943     return 0;
22944   }
22945   arg1 = *argp1;
22946   {
22947     try {
22948       result = Dali::RenderTask::DownCast(arg1);
22949     } catch (std::out_of_range& e) {
22950       {
22951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22952       };
22953     } catch (std::exception& e) {
22954       {
22955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22956       };
22957     } catch (...) {
22958       {
22959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22960       };
22961     }
22962   }
22963   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
22964   return jresult;
22965 }
22966
22967
22968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
22969   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
22970
22971   arg1 = (Dali::RenderTask *)jarg1;
22972   {
22973     try {
22974       delete arg1;
22975     } catch (std::out_of_range& e) {
22976       {
22977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22978       };
22979     } catch (std::exception& e) {
22980       {
22981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22982       };
22983     } catch (...) {
22984       {
22985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22986       };
22987     }
22988   }
22989 }
22990
22991
22992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
22993   void * jresult ;
22994   Dali::RenderTask *arg1 = 0 ;
22995   Dali::RenderTask *result = 0 ;
22996
22997   arg1 = (Dali::RenderTask *)jarg1;
22998   if (!arg1) {
22999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
23000     return 0;
23001   }
23002   {
23003     try {
23004       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
23005     } catch (std::out_of_range& e) {
23006       {
23007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23008       };
23009     } catch (std::exception& e) {
23010       {
23011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23012       };
23013     } catch (...) {
23014       {
23015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23016       };
23017     }
23018   }
23019   jresult = (void *)result;
23020   return jresult;
23021 }
23022
23023
23024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
23025   void * jresult ;
23026   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23027   Dali::RenderTask *arg2 = 0 ;
23028   Dali::RenderTask *result = 0 ;
23029
23030   arg1 = (Dali::RenderTask *)jarg1;
23031   arg2 = (Dali::RenderTask *)jarg2;
23032   if (!arg2) {
23033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
23034     return 0;
23035   }
23036   {
23037     try {
23038       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
23039     } catch (std::out_of_range& e) {
23040       {
23041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23042       };
23043     } catch (std::exception& e) {
23044       {
23045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23046       };
23047     } catch (...) {
23048       {
23049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23050       };
23051     }
23052   }
23053   jresult = (void *)result;
23054   return jresult;
23055 }
23056
23057
23058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
23059   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23060   Dali::Actor arg2 ;
23061   Dali::Actor *argp2 ;
23062
23063   arg1 = (Dali::RenderTask *)jarg1;
23064   argp2 = (Dali::Actor *)jarg2;
23065   if (!argp2) {
23066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
23067     return ;
23068   }
23069   arg2 = *argp2;
23070   {
23071     try {
23072       (arg1)->SetSourceActor(arg2);
23073     } catch (std::out_of_range& e) {
23074       {
23075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23076       };
23077     } catch (std::exception& e) {
23078       {
23079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23080       };
23081     } catch (...) {
23082       {
23083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23084       };
23085     }
23086   }
23087 }
23088
23089
23090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
23091   void * jresult ;
23092   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23093   Dali::Actor result;
23094
23095   arg1 = (Dali::RenderTask *)jarg1;
23096   {
23097     try {
23098       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
23099     } catch (std::out_of_range& e) {
23100       {
23101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23102       };
23103     } catch (std::exception& e) {
23104       {
23105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23106       };
23107     } catch (...) {
23108       {
23109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23110       };
23111     }
23112   }
23113   jresult = new Dali::Actor((const Dali::Actor &)result);
23114   return jresult;
23115 }
23116
23117
23118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
23119   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23120   bool arg2 ;
23121
23122   arg1 = (Dali::RenderTask *)jarg1;
23123   arg2 = jarg2 ? true : false;
23124   {
23125     try {
23126       (arg1)->SetExclusive(arg2);
23127     } catch (std::out_of_range& e) {
23128       {
23129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23130       };
23131     } catch (std::exception& e) {
23132       {
23133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23134       };
23135     } catch (...) {
23136       {
23137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23138       };
23139     }
23140   }
23141 }
23142
23143
23144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
23145   unsigned int jresult ;
23146   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23147   bool result;
23148
23149   arg1 = (Dali::RenderTask *)jarg1;
23150   {
23151     try {
23152       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
23153     } catch (std::out_of_range& e) {
23154       {
23155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23156       };
23157     } catch (std::exception& e) {
23158       {
23159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23160       };
23161     } catch (...) {
23162       {
23163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23164       };
23165     }
23166   }
23167   jresult = result;
23168   return jresult;
23169 }
23170
23171
23172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
23173   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23174   bool arg2 ;
23175
23176   arg1 = (Dali::RenderTask *)jarg1;
23177   arg2 = jarg2 ? true : false;
23178   {
23179     try {
23180       (arg1)->SetInputEnabled(arg2);
23181     } catch (std::out_of_range& e) {
23182       {
23183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23184       };
23185     } catch (std::exception& e) {
23186       {
23187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23188       };
23189     } catch (...) {
23190       {
23191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23192       };
23193     }
23194   }
23195 }
23196
23197
23198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
23199   unsigned int jresult ;
23200   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23201   bool result;
23202
23203   arg1 = (Dali::RenderTask *)jarg1;
23204   {
23205     try {
23206       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
23207     } catch (std::out_of_range& e) {
23208       {
23209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23210       };
23211     } catch (std::exception& e) {
23212       {
23213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23214       };
23215     } catch (...) {
23216       {
23217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23218       };
23219     }
23220   }
23221   jresult = result;
23222   return jresult;
23223 }
23224
23225
23226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
23227   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23228   Dali::CameraActor arg2 ;
23229   Dali::CameraActor *argp2 ;
23230
23231   arg1 = (Dali::RenderTask *)jarg1;
23232   argp2 = (Dali::CameraActor *)jarg2;
23233   if (!argp2) {
23234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
23235     return ;
23236   }
23237   arg2 = *argp2;
23238   {
23239     try {
23240       (arg1)->SetCameraActor(arg2);
23241     } catch (std::out_of_range& e) {
23242       {
23243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23244       };
23245     } catch (std::exception& e) {
23246       {
23247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23248       };
23249     } catch (...) {
23250       {
23251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23252       };
23253     }
23254   }
23255 }
23256
23257
23258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
23259   void * jresult ;
23260   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23261   Dali::CameraActor result;
23262
23263   arg1 = (Dali::RenderTask *)jarg1;
23264   {
23265     try {
23266       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
23267     } catch (std::out_of_range& e) {
23268       {
23269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23270       };
23271     } catch (std::exception& e) {
23272       {
23273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23274       };
23275     } catch (...) {
23276       {
23277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23278       };
23279     }
23280   }
23281   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
23282   return jresult;
23283 }
23284
23285
23286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
23287   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23288   Dali::FrameBufferImage arg2 ;
23289   Dali::FrameBufferImage *argp2 ;
23290
23291   arg1 = (Dali::RenderTask *)jarg1;
23292   argp2 = (Dali::FrameBufferImage *)jarg2;
23293   if (!argp2) {
23294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
23295     return ;
23296   }
23297   arg2 = *argp2;
23298   {
23299     try {
23300       (arg1)->SetTargetFrameBuffer(arg2);
23301     } catch (std::out_of_range& e) {
23302       {
23303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23304       };
23305     } catch (std::exception& e) {
23306       {
23307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23308       };
23309     } catch (...) {
23310       {
23311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23312       };
23313     }
23314   }
23315 }
23316
23317
23318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
23319   void * jresult ;
23320   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23321   Dali::FrameBufferImage result;
23322
23323   arg1 = (Dali::RenderTask *)jarg1;
23324   {
23325     try {
23326       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
23327     } catch (std::out_of_range& e) {
23328       {
23329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23330       };
23331     } catch (std::exception& e) {
23332       {
23333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23334       };
23335     } catch (...) {
23336       {
23337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23338       };
23339     }
23340   }
23341   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
23347   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23348   Dali::FrameBuffer arg2 ;
23349   Dali::FrameBuffer *argp2 ;
23350
23351   arg1 = (Dali::RenderTask *)jarg1;
23352   argp2 = (Dali::FrameBuffer *)jarg2;
23353   if (!argp2) {
23354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
23355     return ;
23356   }
23357   arg2 = *argp2;
23358   {
23359     try {
23360       (arg1)->SetFrameBuffer(arg2);
23361     } catch (std::out_of_range& e) {
23362       {
23363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23364       };
23365     } catch (std::exception& e) {
23366       {
23367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23368       };
23369     } catch (...) {
23370       {
23371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23372       };
23373     }
23374   }
23375 }
23376
23377
23378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
23379   void * jresult ;
23380   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23381   Dali::FrameBuffer result;
23382
23383   arg1 = (Dali::RenderTask *)jarg1;
23384   {
23385     try {
23386       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
23387     } catch (std::out_of_range& e) {
23388       {
23389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23390       };
23391     } catch (std::exception& e) {
23392       {
23393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23394       };
23395     } catch (...) {
23396       {
23397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23398       };
23399     }
23400   }
23401   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
23402   return jresult;
23403 }
23404
23405
23406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
23407   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23408   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
23409
23410   arg1 = (Dali::RenderTask *)jarg1;
23411   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
23412   {
23413     try {
23414       (arg1)->SetScreenToFrameBufferFunction(arg2);
23415     } catch (std::out_of_range& e) {
23416       {
23417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23418       };
23419     } catch (std::exception& e) {
23420       {
23421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23422       };
23423     } catch (...) {
23424       {
23425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23426       };
23427     }
23428   }
23429 }
23430
23431
23432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
23433   void * jresult ;
23434   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23435   Dali::RenderTask::ScreenToFrameBufferFunction result;
23436
23437   arg1 = (Dali::RenderTask *)jarg1;
23438   {
23439     try {
23440       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
23441     } catch (std::out_of_range& e) {
23442       {
23443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23444       };
23445     } catch (std::exception& e) {
23446       {
23447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23448       };
23449     } catch (...) {
23450       {
23451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23452       };
23453     }
23454   }
23455   jresult = (void *)result;
23456   return jresult;
23457 }
23458
23459
23460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
23461   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23462   Dali::Actor arg2 ;
23463   Dali::Actor *argp2 ;
23464
23465   arg1 = (Dali::RenderTask *)jarg1;
23466   argp2 = (Dali::Actor *)jarg2;
23467   if (!argp2) {
23468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
23469     return ;
23470   }
23471   arg2 = *argp2;
23472   {
23473     try {
23474       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
23475     } catch (std::out_of_range& e) {
23476       {
23477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23478       };
23479     } catch (std::exception& e) {
23480       {
23481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23482       };
23483     } catch (...) {
23484       {
23485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23486       };
23487     }
23488   }
23489 }
23490
23491
23492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
23493   void * jresult ;
23494   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23495   Dali::Actor result;
23496
23497   arg1 = (Dali::RenderTask *)jarg1;
23498   {
23499     try {
23500       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
23501     } catch (std::out_of_range& e) {
23502       {
23503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23504       };
23505     } catch (std::exception& e) {
23506       {
23507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23508       };
23509     } catch (...) {
23510       {
23511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23512       };
23513     }
23514   }
23515   jresult = new Dali::Actor((const Dali::Actor &)result);
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
23521   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23522   Dali::Vector2 arg2 ;
23523   Dali::Vector2 *argp2 ;
23524
23525   arg1 = (Dali::RenderTask *)jarg1;
23526   argp2 = (Dali::Vector2 *)jarg2;
23527   if (!argp2) {
23528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
23529     return ;
23530   }
23531   arg2 = *argp2;
23532   {
23533     try {
23534       (arg1)->SetViewportPosition(arg2);
23535     } catch (std::out_of_range& e) {
23536       {
23537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23538       };
23539     } catch (std::exception& e) {
23540       {
23541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23542       };
23543     } catch (...) {
23544       {
23545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23546       };
23547     }
23548   }
23549 }
23550
23551
23552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
23553   void * jresult ;
23554   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23555   Dali::Vector2 result;
23556
23557   arg1 = (Dali::RenderTask *)jarg1;
23558   {
23559     try {
23560       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
23561     } catch (std::out_of_range& e) {
23562       {
23563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23564       };
23565     } catch (std::exception& e) {
23566       {
23567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23568       };
23569     } catch (...) {
23570       {
23571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23572       };
23573     }
23574   }
23575   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23576   return jresult;
23577 }
23578
23579
23580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
23581   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23582   Dali::Vector2 arg2 ;
23583   Dali::Vector2 *argp2 ;
23584
23585   arg1 = (Dali::RenderTask *)jarg1;
23586   argp2 = (Dali::Vector2 *)jarg2;
23587   if (!argp2) {
23588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
23589     return ;
23590   }
23591   arg2 = *argp2;
23592   {
23593     try {
23594       (arg1)->SetViewportSize(arg2);
23595     } catch (std::out_of_range& e) {
23596       {
23597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23598       };
23599     } catch (std::exception& e) {
23600       {
23601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23602       };
23603     } catch (...) {
23604       {
23605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23606       };
23607     }
23608   }
23609 }
23610
23611
23612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
23613   void * jresult ;
23614   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23615   Dali::Vector2 result;
23616
23617   arg1 = (Dali::RenderTask *)jarg1;
23618   {
23619     try {
23620       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
23621     } catch (std::out_of_range& e) {
23622       {
23623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23624       };
23625     } catch (std::exception& e) {
23626       {
23627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23628       };
23629     } catch (...) {
23630       {
23631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23632       };
23633     }
23634   }
23635   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23636   return jresult;
23637 }
23638
23639
23640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
23641   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23642   Dali::Viewport arg2 ;
23643   Dali::Viewport *argp2 ;
23644
23645   arg1 = (Dali::RenderTask *)jarg1;
23646   argp2 = (Dali::Viewport *)jarg2;
23647   if (!argp2) {
23648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
23649     return ;
23650   }
23651   arg2 = *argp2;
23652   {
23653     try {
23654       (arg1)->SetViewport(arg2);
23655     } catch (std::out_of_range& e) {
23656       {
23657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23658       };
23659     } catch (std::exception& e) {
23660       {
23661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23662       };
23663     } catch (...) {
23664       {
23665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23666       };
23667     }
23668   }
23669 }
23670
23671
23672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
23673   void * jresult ;
23674   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23675   Dali::Viewport result;
23676
23677   arg1 = (Dali::RenderTask *)jarg1;
23678   {
23679     try {
23680       result = ((Dali::RenderTask const *)arg1)->GetViewport();
23681     } catch (std::out_of_range& e) {
23682       {
23683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23684       };
23685     } catch (std::exception& e) {
23686       {
23687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23688       };
23689     } catch (...) {
23690       {
23691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23692       };
23693     }
23694   }
23695   jresult = new Dali::Viewport((const Dali::Viewport &)result);
23696   return jresult;
23697 }
23698
23699
23700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
23701   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23702   Dali::Vector4 *arg2 = 0 ;
23703
23704   arg1 = (Dali::RenderTask *)jarg1;
23705   arg2 = (Dali::Vector4 *)jarg2;
23706   if (!arg2) {
23707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
23708     return ;
23709   }
23710   {
23711     try {
23712       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
23713     } catch (std::out_of_range& e) {
23714       {
23715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23716       };
23717     } catch (std::exception& e) {
23718       {
23719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23720       };
23721     } catch (...) {
23722       {
23723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23724       };
23725     }
23726   }
23727 }
23728
23729
23730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
23731   void * jresult ;
23732   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23733   Dali::Vector4 result;
23734
23735   arg1 = (Dali::RenderTask *)jarg1;
23736   {
23737     try {
23738       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
23739     } catch (std::out_of_range& e) {
23740       {
23741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23742       };
23743     } catch (std::exception& e) {
23744       {
23745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23746       };
23747     } catch (...) {
23748       {
23749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23750       };
23751     }
23752   }
23753   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
23754   return jresult;
23755 }
23756
23757
23758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
23759   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23760   bool arg2 ;
23761
23762   arg1 = (Dali::RenderTask *)jarg1;
23763   arg2 = jarg2 ? true : false;
23764   {
23765     try {
23766       (arg1)->SetClearEnabled(arg2);
23767     } catch (std::out_of_range& e) {
23768       {
23769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23770       };
23771     } catch (std::exception& e) {
23772       {
23773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23774       };
23775     } catch (...) {
23776       {
23777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23778       };
23779     }
23780   }
23781 }
23782
23783
23784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
23785   unsigned int jresult ;
23786   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23787   bool result;
23788
23789   arg1 = (Dali::RenderTask *)jarg1;
23790   {
23791     try {
23792       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
23793     } catch (std::out_of_range& e) {
23794       {
23795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23796       };
23797     } catch (std::exception& e) {
23798       {
23799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23800       };
23801     } catch (...) {
23802       {
23803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23804       };
23805     }
23806   }
23807   jresult = result;
23808   return jresult;
23809 }
23810
23811
23812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
23813   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23814   bool arg2 ;
23815
23816   arg1 = (Dali::RenderTask *)jarg1;
23817   arg2 = jarg2 ? true : false;
23818   {
23819     try {
23820       (arg1)->SetCullMode(arg2);
23821     } catch (std::out_of_range& e) {
23822       {
23823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23824       };
23825     } catch (std::exception& e) {
23826       {
23827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23828       };
23829     } catch (...) {
23830       {
23831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23832       };
23833     }
23834   }
23835 }
23836
23837
23838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
23839   unsigned int jresult ;
23840   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23841   bool result;
23842
23843   arg1 = (Dali::RenderTask *)jarg1;
23844   {
23845     try {
23846       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
23847     } catch (std::out_of_range& e) {
23848       {
23849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23850       };
23851     } catch (std::exception& e) {
23852       {
23853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23854       };
23855     } catch (...) {
23856       {
23857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23858       };
23859     }
23860   }
23861   jresult = result;
23862   return jresult;
23863 }
23864
23865
23866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
23867   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23868   unsigned int arg2 ;
23869
23870   arg1 = (Dali::RenderTask *)jarg1;
23871   arg2 = (unsigned int)jarg2;
23872   {
23873     try {
23874       (arg1)->SetRefreshRate(arg2);
23875     } catch (std::out_of_range& e) {
23876       {
23877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23878       };
23879     } catch (std::exception& e) {
23880       {
23881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23882       };
23883     } catch (...) {
23884       {
23885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23886       };
23887     }
23888   }
23889 }
23890
23891
23892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
23893   unsigned int jresult ;
23894   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23895   unsigned int result;
23896
23897   arg1 = (Dali::RenderTask *)jarg1;
23898   {
23899     try {
23900       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
23901     } catch (std::out_of_range& e) {
23902       {
23903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23904       };
23905     } catch (std::exception& e) {
23906       {
23907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23908       };
23909     } catch (...) {
23910       {
23911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23912       };
23913     }
23914   }
23915   jresult = result;
23916   return jresult;
23917 }
23918
23919
23920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
23921   unsigned int jresult ;
23922   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23923   Dali::Vector3 *arg2 = 0 ;
23924   float *arg3 = 0 ;
23925   float *arg4 = 0 ;
23926   bool result;
23927
23928   arg1 = (Dali::RenderTask *)jarg1;
23929   arg2 = (Dali::Vector3 *)jarg2;
23930   if (!arg2) {
23931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23932     return 0;
23933   }
23934   arg3 = (float *)jarg3;
23935   arg4 = (float *)jarg4;
23936   {
23937     try {
23938       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
23939     } catch (std::out_of_range& e) {
23940       {
23941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23942       };
23943     } catch (std::exception& e) {
23944       {
23945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23946       };
23947     } catch (...) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23950       };
23951     }
23952   }
23953   jresult = result;
23954   return jresult;
23955 }
23956
23957
23958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
23959   unsigned int jresult ;
23960   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
23961   Dali::Actor arg2 ;
23962   float arg3 ;
23963   float arg4 ;
23964   float *arg5 = 0 ;
23965   float *arg6 = 0 ;
23966   Dali::Actor *argp2 ;
23967   bool result;
23968
23969   arg1 = (Dali::RenderTask *)jarg1;
23970   argp2 = (Dali::Actor *)jarg2;
23971   if (!argp2) {
23972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
23973     return 0;
23974   }
23975   arg2 = *argp2;
23976   arg3 = (float)jarg3;
23977   arg4 = (float)jarg4;
23978   arg5 = (float *)jarg5;
23979   arg6 = (float *)jarg6;
23980   {
23981     try {
23982       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
23983     } catch (std::out_of_range& e) {
23984       {
23985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23986       };
23987     } catch (std::exception& e) {
23988       {
23989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23990       };
23991     } catch (...) {
23992       {
23993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23994       };
23995     }
23996   }
23997   jresult = result;
23998   return jresult;
23999 }
24000
24001
24002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
24003   void * jresult ;
24004   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24005   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
24006
24007   arg1 = (Dali::RenderTask *)jarg1;
24008   {
24009     try {
24010       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
24011     } catch (std::out_of_range& e) {
24012       {
24013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24014       };
24015     } catch (std::exception& e) {
24016       {
24017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24018       };
24019     } catch (...) {
24020       {
24021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24022       };
24023     }
24024   }
24025   jresult = (void *)result;
24026   return jresult;
24027 }
24028
24029
24030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
24031   void * jresult ;
24032   int arg1 ;
24033   Dali::TouchPoint::State arg2 ;
24034   float arg3 ;
24035   float arg4 ;
24036   Dali::TouchPoint *result = 0 ;
24037
24038   arg1 = (int)jarg1;
24039   arg2 = (Dali::TouchPoint::State)jarg2;
24040   arg3 = (float)jarg3;
24041   arg4 = (float)jarg4;
24042   {
24043     try {
24044       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
24045     } catch (std::out_of_range& e) {
24046       {
24047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24048       };
24049     } catch (std::exception& e) {
24050       {
24051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24052       };
24053     } catch (...) {
24054       {
24055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24056       };
24057     }
24058   }
24059   jresult = (void *)result;
24060   return jresult;
24061 }
24062
24063
24064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
24065   void * jresult ;
24066   int arg1 ;
24067   Dali::TouchPoint::State arg2 ;
24068   float arg3 ;
24069   float arg4 ;
24070   float arg5 ;
24071   float arg6 ;
24072   Dali::TouchPoint *result = 0 ;
24073
24074   arg1 = (int)jarg1;
24075   arg2 = (Dali::TouchPoint::State)jarg2;
24076   arg3 = (float)jarg3;
24077   arg4 = (float)jarg4;
24078   arg5 = (float)jarg5;
24079   arg6 = (float)jarg6;
24080   {
24081     try {
24082       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
24083     } catch (std::out_of_range& e) {
24084       {
24085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24086       };
24087     } catch (std::exception& e) {
24088       {
24089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24090       };
24091     } catch (...) {
24092       {
24093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24094       };
24095     }
24096   }
24097   jresult = (void *)result;
24098   return jresult;
24099 }
24100
24101
24102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
24103   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24104
24105   arg1 = (Dali::TouchPoint *)jarg1;
24106   {
24107     try {
24108       delete arg1;
24109     } catch (std::out_of_range& e) {
24110       {
24111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24112       };
24113     } catch (std::exception& e) {
24114       {
24115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24116       };
24117     } catch (...) {
24118       {
24119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24120       };
24121     }
24122   }
24123 }
24124
24125
24126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
24127   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24128   int arg2 ;
24129
24130   arg1 = (Dali::TouchPoint *)jarg1;
24131   arg2 = (int)jarg2;
24132   if (arg1) (arg1)->deviceId = arg2;
24133 }
24134
24135
24136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
24137   int jresult ;
24138   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24139   int result;
24140
24141   arg1 = (Dali::TouchPoint *)jarg1;
24142   result = (int) ((arg1)->deviceId);
24143   jresult = result;
24144   return jresult;
24145 }
24146
24147
24148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
24149   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24150   Dali::TouchPoint::State arg2 ;
24151
24152   arg1 = (Dali::TouchPoint *)jarg1;
24153   arg2 = (Dali::TouchPoint::State)jarg2;
24154   if (arg1) (arg1)->state = arg2;
24155 }
24156
24157
24158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
24159   int jresult ;
24160   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24161   Dali::TouchPoint::State result;
24162
24163   arg1 = (Dali::TouchPoint *)jarg1;
24164   result = (Dali::TouchPoint::State) ((arg1)->state);
24165   jresult = (int)result;
24166   return jresult;
24167 }
24168
24169
24170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
24171   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24172   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
24173
24174   arg1 = (Dali::TouchPoint *)jarg1;
24175   arg2 = (Dali::Actor *)jarg2;
24176   if (arg1) (arg1)->hitActor = *arg2;
24177 }
24178
24179
24180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
24181   void * jresult ;
24182   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24183   Dali::Actor *result = 0 ;
24184
24185   arg1 = (Dali::TouchPoint *)jarg1;
24186   result = (Dali::Actor *)& ((arg1)->hitActor);
24187   jresult = (void *)result;
24188   return jresult;
24189 }
24190
24191
24192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
24193   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24194   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
24195
24196   arg1 = (Dali::TouchPoint *)jarg1;
24197   arg2 = (Dali::Vector2 *)jarg2;
24198   if (arg1) (arg1)->local = *arg2;
24199 }
24200
24201
24202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
24203   void * jresult ;
24204   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24205   Dali::Vector2 *result = 0 ;
24206
24207   arg1 = (Dali::TouchPoint *)jarg1;
24208   result = (Dali::Vector2 *)& ((arg1)->local);
24209   jresult = (void *)result;
24210   return jresult;
24211 }
24212
24213
24214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
24215   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24216   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
24217
24218   arg1 = (Dali::TouchPoint *)jarg1;
24219   arg2 = (Dali::Vector2 *)jarg2;
24220   if (arg1) (arg1)->screen = *arg2;
24221 }
24222
24223
24224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
24225   void * jresult ;
24226   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
24227   Dali::Vector2 *result = 0 ;
24228
24229   arg1 = (Dali::TouchPoint *)jarg1;
24230   result = (Dali::Vector2 *)& ((arg1)->screen);
24231   jresult = (void *)result;
24232   return jresult;
24233 }
24234
24235
24236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchData__SWIG_0() {
24237   void * jresult ;
24238   Dali::TouchData *result = 0 ;
24239
24240   {
24241     try {
24242       result = (Dali::TouchData *)new Dali::TouchData();
24243     } catch (std::out_of_range& e) {
24244       {
24245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24246       };
24247     } catch (std::exception& e) {
24248       {
24249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24250       };
24251     } catch (...) {
24252       {
24253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24254       };
24255     }
24256   }
24257   jresult = (void *)result;
24258   return jresult;
24259 }
24260
24261
24262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchData__SWIG_1(void * jarg1) {
24263   void * jresult ;
24264   Dali::TouchData *arg1 = 0 ;
24265   Dali::TouchData *result = 0 ;
24266
24267   arg1 = (Dali::TouchData *)jarg1;
24268   if (!arg1) {
24269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
24270     return 0;
24271   }
24272   {
24273     try {
24274       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
24275     } catch (std::out_of_range& e) {
24276       {
24277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24278       };
24279     } catch (std::exception& e) {
24280       {
24281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24282       };
24283     } catch (...) {
24284       {
24285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24286       };
24287     }
24288   }
24289   jresult = (void *)result;
24290   return jresult;
24291 }
24292
24293
24294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchData(void * jarg1) {
24295   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24296
24297   arg1 = (Dali::TouchData *)jarg1;
24298   {
24299     try {
24300       delete arg1;
24301     } catch (std::out_of_range& e) {
24302       {
24303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24304       };
24305     } catch (std::exception& e) {
24306       {
24307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24308       };
24309     } catch (...) {
24310       {
24311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24312       };
24313     }
24314   }
24315 }
24316
24317
24318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchData_Assign(void * jarg1, void * jarg2) {
24319   void * jresult ;
24320   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24321   Dali::TouchData *arg2 = 0 ;
24322   Dali::TouchData *result = 0 ;
24323
24324   arg1 = (Dali::TouchData *)jarg1;
24325   arg2 = (Dali::TouchData *)jarg2;
24326   if (!arg2) {
24327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
24328     return 0;
24329   }
24330   {
24331     try {
24332       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
24333     } catch (std::out_of_range& e) {
24334       {
24335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24336       };
24337     } catch (std::exception& e) {
24338       {
24339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24340       };
24341     } catch (...) {
24342       {
24343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24344       };
24345     }
24346   }
24347   jresult = (void *)result;
24348   return jresult;
24349 }
24350
24351
24352 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchData_GetTime(void * jarg1) {
24353   unsigned long jresult ;
24354   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24355   unsigned long result;
24356
24357   arg1 = (Dali::TouchData *)jarg1;
24358   {
24359     try {
24360       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
24361     } catch (std::out_of_range& e) {
24362       {
24363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24364       };
24365     } catch (std::exception& e) {
24366       {
24367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24368       };
24369     } catch (...) {
24370       {
24371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24372       };
24373     }
24374   }
24375   jresult = (unsigned long)result;
24376   return jresult;
24377 }
24378
24379
24380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchData_GetPointCount(void * jarg1) {
24381   unsigned long jresult ;
24382   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24383   std::size_t result;
24384
24385   arg1 = (Dali::TouchData *)jarg1;
24386   {
24387     try {
24388       result = ((Dali::TouchData const *)arg1)->GetPointCount();
24389     } catch (std::out_of_range& e) {
24390       {
24391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24392       };
24393     } catch (std::exception& e) {
24394       {
24395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24396       };
24397     } catch (...) {
24398       {
24399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24400       };
24401     }
24402   }
24403   jresult = (unsigned long)result;
24404   return jresult;
24405 }
24406
24407
24408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchData_GetDeviceId(void * jarg1, unsigned long jarg2) {
24409   int jresult ;
24410   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24411   std::size_t arg2 ;
24412   int32_t result;
24413
24414   arg1 = (Dali::TouchData *)jarg1;
24415   arg2 = (std::size_t)jarg2;
24416   {
24417     try {
24418       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
24419     } catch (std::out_of_range& e) {
24420       {
24421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24422       };
24423     } catch (std::exception& e) {
24424       {
24425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24426       };
24427     } catch (...) {
24428       {
24429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24430       };
24431     }
24432   }
24433   jresult = result;
24434   return jresult;
24435 }
24436
24437
24438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchData_GetState(void * jarg1, unsigned long jarg2) {
24439   int jresult ;
24440   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24441   std::size_t arg2 ;
24442   Dali::PointState::Type result;
24443
24444   arg1 = (Dali::TouchData *)jarg1;
24445   arg2 = (std::size_t)jarg2;
24446   {
24447     try {
24448       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
24449     } catch (std::out_of_range& e) {
24450       {
24451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24452       };
24453     } catch (std::exception& e) {
24454       {
24455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24456       };
24457     } catch (...) {
24458       {
24459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24460       };
24461     }
24462   }
24463   jresult = (int)result;
24464   return jresult;
24465 }
24466
24467
24468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchData_GetHitActor(void * jarg1, unsigned long jarg2) {
24469   void * jresult ;
24470   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24471   std::size_t arg2 ;
24472   Dali::Actor result;
24473
24474   arg1 = (Dali::TouchData *)jarg1;
24475   arg2 = (std::size_t)jarg2;
24476   {
24477     try {
24478       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
24479     } catch (std::out_of_range& e) {
24480       {
24481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24482       };
24483     } catch (std::exception& e) {
24484       {
24485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24486       };
24487     } catch (...) {
24488       {
24489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24490       };
24491     }
24492   }
24493   jresult = new Dali::Actor((const Dali::Actor &)result);
24494   return jresult;
24495 }
24496
24497
24498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchData_GetLocalPosition(void * jarg1, unsigned long jarg2) {
24499   void * jresult ;
24500   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24501   std::size_t arg2 ;
24502   Dali::Vector2 *result = 0 ;
24503
24504   arg1 = (Dali::TouchData *)jarg1;
24505   arg2 = (std::size_t)jarg2;
24506   {
24507     try {
24508       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
24509     } catch (std::out_of_range& e) {
24510       {
24511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24512       };
24513     } catch (std::exception& e) {
24514       {
24515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24516       };
24517     } catch (...) {
24518       {
24519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24520       };
24521     }
24522   }
24523   jresult = (void *)result;
24524   return jresult;
24525 }
24526
24527
24528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchData_GetScreenPosition(void * jarg1, unsigned long jarg2) {
24529   void * jresult ;
24530   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24531   std::size_t arg2 ;
24532   Dali::Vector2 *result = 0 ;
24533
24534   arg1 = (Dali::TouchData *)jarg1;
24535   arg2 = (std::size_t)jarg2;
24536   {
24537     try {
24538       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
24539     } catch (std::out_of_range& e) {
24540       {
24541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24542       };
24543     } catch (std::exception& e) {
24544       {
24545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24546       };
24547     } catch (...) {
24548       {
24549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24550       };
24551     }
24552   }
24553   jresult = (void *)result;
24554   return jresult;
24555 }
24556
24557
24558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TouchData_GetRadius(void * jarg1, unsigned long jarg2) {
24559   float jresult ;
24560   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24561   std::size_t arg2 ;
24562   float result;
24563
24564   arg1 = (Dali::TouchData *)jarg1;
24565   arg2 = (std::size_t)jarg2;
24566   {
24567     try {
24568       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
24569     } catch (std::out_of_range& e) {
24570       {
24571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24572       };
24573     } catch (std::exception& e) {
24574       {
24575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24576       };
24577     } catch (...) {
24578       {
24579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24580       };
24581     }
24582   }
24583   jresult = result;
24584   return jresult;
24585 }
24586
24587
24588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchData_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
24589   void * jresult ;
24590   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24591   std::size_t arg2 ;
24592   Dali::Vector2 *result = 0 ;
24593
24594   arg1 = (Dali::TouchData *)jarg1;
24595   arg2 = (std::size_t)jarg2;
24596   {
24597     try {
24598       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
24599     } catch (std::out_of_range& e) {
24600       {
24601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24602       };
24603     } catch (std::exception& e) {
24604       {
24605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24606       };
24607     } catch (...) {
24608       {
24609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24610       };
24611     }
24612   }
24613   jresult = (void *)result;
24614   return jresult;
24615 }
24616
24617
24618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TouchData_GetPressure(void * jarg1, unsigned long jarg2) {
24619   float jresult ;
24620   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24621   std::size_t arg2 ;
24622   float result;
24623
24624   arg1 = (Dali::TouchData *)jarg1;
24625   arg2 = (std::size_t)jarg2;
24626   {
24627     try {
24628       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
24629     } catch (std::out_of_range& e) {
24630       {
24631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24632       };
24633     } catch (std::exception& e) {
24634       {
24635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24636       };
24637     } catch (...) {
24638       {
24639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24640       };
24641     }
24642   }
24643   jresult = result;
24644   return jresult;
24645 }
24646
24647
24648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchData_GetAngle(void * jarg1, unsigned long jarg2) {
24649   void * jresult ;
24650   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
24651   std::size_t arg2 ;
24652   Dali::Degree result;
24653
24654   arg1 = (Dali::TouchData *)jarg1;
24655   arg2 = (std::size_t)jarg2;
24656   {
24657     try {
24658       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
24659     } catch (std::out_of_range& e) {
24660       {
24661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24662       };
24663     } catch (std::exception& e) {
24664       {
24665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24666       };
24667     } catch (...) {
24668       {
24669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24670       };
24671     }
24672   }
24673   jresult = new Dali::Degree((const Dali::Degree &)result);
24674   return jresult;
24675 }
24676
24677
24678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
24679   void * jresult ;
24680   Dali::GestureDetector *result = 0 ;
24681
24682   {
24683     try {
24684       result = (Dali::GestureDetector *)new Dali::GestureDetector();
24685     } catch (std::out_of_range& e) {
24686       {
24687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24688       };
24689     } catch (std::exception& e) {
24690       {
24691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24692       };
24693     } catch (...) {
24694       {
24695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24696       };
24697     }
24698   }
24699   jresult = (void *)result;
24700   return jresult;
24701 }
24702
24703
24704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
24705   void * jresult ;
24706   Dali::BaseHandle arg1 ;
24707   Dali::BaseHandle *argp1 ;
24708   Dali::GestureDetector result;
24709
24710   argp1 = (Dali::BaseHandle *)jarg1;
24711   if (!argp1) {
24712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24713     return 0;
24714   }
24715   arg1 = *argp1;
24716   {
24717     try {
24718       result = Dali::GestureDetector::DownCast(arg1);
24719     } catch (std::out_of_range& e) {
24720       {
24721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24722       };
24723     } catch (std::exception& e) {
24724       {
24725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24726       };
24727     } catch (...) {
24728       {
24729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24730       };
24731     }
24732   }
24733   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
24734   return jresult;
24735 }
24736
24737
24738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
24739   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
24740
24741   arg1 = (Dali::GestureDetector *)jarg1;
24742   {
24743     try {
24744       delete arg1;
24745     } catch (std::out_of_range& e) {
24746       {
24747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24748       };
24749     } catch (std::exception& e) {
24750       {
24751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24752       };
24753     } catch (...) {
24754       {
24755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24756       };
24757     }
24758   }
24759 }
24760
24761
24762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
24763   void * jresult ;
24764   Dali::GestureDetector *arg1 = 0 ;
24765   Dali::GestureDetector *result = 0 ;
24766
24767   arg1 = (Dali::GestureDetector *)jarg1;
24768   if (!arg1) {
24769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
24770     return 0;
24771   }
24772   {
24773     try {
24774       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
24775     } catch (std::out_of_range& e) {
24776       {
24777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24778       };
24779     } catch (std::exception& e) {
24780       {
24781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24782       };
24783     } catch (...) {
24784       {
24785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24786       };
24787     }
24788   }
24789   jresult = (void *)result;
24790   return jresult;
24791 }
24792
24793
24794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
24795   void * jresult ;
24796   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
24797   Dali::GestureDetector *arg2 = 0 ;
24798   Dali::GestureDetector *result = 0 ;
24799
24800   arg1 = (Dali::GestureDetector *)jarg1;
24801   arg2 = (Dali::GestureDetector *)jarg2;
24802   if (!arg2) {
24803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
24804     return 0;
24805   }
24806   {
24807     try {
24808       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
24809     } catch (std::out_of_range& e) {
24810       {
24811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24812       };
24813     } catch (std::exception& e) {
24814       {
24815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24816       };
24817     } catch (...) {
24818       {
24819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24820       };
24821     }
24822   }
24823   jresult = (void *)result;
24824   return jresult;
24825 }
24826
24827
24828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
24829   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
24830   Dali::Actor arg2 ;
24831   Dali::Actor *argp2 ;
24832
24833   arg1 = (Dali::GestureDetector *)jarg1;
24834   argp2 = (Dali::Actor *)jarg2;
24835   if (!argp2) {
24836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24837     return ;
24838   }
24839   arg2 = *argp2;
24840   {
24841     try {
24842       (arg1)->Attach(arg2);
24843     } catch (std::out_of_range& e) {
24844       {
24845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24846       };
24847     } catch (std::exception& e) {
24848       {
24849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24850       };
24851     } catch (...) {
24852       {
24853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24854       };
24855     }
24856   }
24857 }
24858
24859
24860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
24861   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
24862   Dali::Actor arg2 ;
24863   Dali::Actor *argp2 ;
24864
24865   arg1 = (Dali::GestureDetector *)jarg1;
24866   argp2 = (Dali::Actor *)jarg2;
24867   if (!argp2) {
24868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24869     return ;
24870   }
24871   arg2 = *argp2;
24872   {
24873     try {
24874       (arg1)->Detach(arg2);
24875     } catch (std::out_of_range& e) {
24876       {
24877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24878       };
24879     } catch (std::exception& e) {
24880       {
24881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24882       };
24883     } catch (...) {
24884       {
24885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24886       };
24887     }
24888   }
24889 }
24890
24891
24892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
24893   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
24894
24895   arg1 = (Dali::GestureDetector *)jarg1;
24896   {
24897     try {
24898       (arg1)->DetachAll();
24899     } catch (std::out_of_range& e) {
24900       {
24901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24902       };
24903     } catch (std::exception& e) {
24904       {
24905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24906       };
24907     } catch (...) {
24908       {
24909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24910       };
24911     }
24912   }
24913 }
24914
24915
24916 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
24917   unsigned long jresult ;
24918   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
24919   size_t result;
24920
24921   arg1 = (Dali::GestureDetector *)jarg1;
24922   {
24923     try {
24924       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
24925     } catch (std::out_of_range& e) {
24926       {
24927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24928       };
24929     } catch (std::exception& e) {
24930       {
24931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24932       };
24933     } catch (...) {
24934       {
24935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24936       };
24937     }
24938   }
24939   jresult = (unsigned long)result;
24940   return jresult;
24941 }
24942
24943
24944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
24945   void * jresult ;
24946   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
24947   size_t arg2 ;
24948   Dali::Actor result;
24949
24950   arg1 = (Dali::GestureDetector *)jarg1;
24951   arg2 = (size_t)jarg2;
24952   {
24953     try {
24954       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
24955     } catch (std::out_of_range& e) {
24956       {
24957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24958       };
24959     } catch (std::exception& e) {
24960       {
24961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24962       };
24963     } catch (...) {
24964       {
24965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24966       };
24967     }
24968   }
24969   jresult = new Dali::Actor((const Dali::Actor &)result);
24970   return jresult;
24971 }
24972
24973
24974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
24975   void * jresult ;
24976   Dali::Gesture *arg1 = 0 ;
24977   Dali::Gesture *result = 0 ;
24978
24979   arg1 = (Dali::Gesture *)jarg1;
24980   if (!arg1) {
24981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
24982     return 0;
24983   }
24984   {
24985     try {
24986       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
24987     } catch (std::out_of_range& e) {
24988       {
24989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24990       };
24991     } catch (std::exception& e) {
24992       {
24993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24994       };
24995     } catch (...) {
24996       {
24997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24998       };
24999     }
25000   }
25001   jresult = (void *)result;
25002   return jresult;
25003 }
25004
25005
25006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
25007   void * jresult ;
25008   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
25009   Dali::Gesture *arg2 = 0 ;
25010   Dali::Gesture *result = 0 ;
25011
25012   arg1 = (Dali::Gesture *)jarg1;
25013   arg2 = (Dali::Gesture *)jarg2;
25014   if (!arg2) {
25015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
25016     return 0;
25017   }
25018   {
25019     try {
25020       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
25021     } catch (std::out_of_range& e) {
25022       {
25023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25024       };
25025     } catch (std::exception& e) {
25026       {
25027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25028       };
25029     } catch (...) {
25030       {
25031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25032       };
25033     }
25034   }
25035   jresult = (void *)result;
25036   return jresult;
25037 }
25038
25039
25040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
25041   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
25042
25043   arg1 = (Dali::Gesture *)jarg1;
25044   {
25045     try {
25046       delete arg1;
25047     } catch (std::out_of_range& e) {
25048       {
25049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25050       };
25051     } catch (std::exception& e) {
25052       {
25053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25054       };
25055     } catch (...) {
25056       {
25057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25058       };
25059     }
25060   }
25061 }
25062
25063
25064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
25065   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
25066   Dali::Gesture::Type arg2 ;
25067
25068   arg1 = (Dali::Gesture *)jarg1;
25069   arg2 = (Dali::Gesture::Type)jarg2;
25070   if (arg1) (arg1)->type = arg2;
25071 }
25072
25073
25074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
25075   int jresult ;
25076   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
25077   Dali::Gesture::Type result;
25078
25079   arg1 = (Dali::Gesture *)jarg1;
25080   result = (Dali::Gesture::Type) ((arg1)->type);
25081   jresult = (int)result;
25082   return jresult;
25083 }
25084
25085
25086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
25087   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
25088   Dali::Gesture::State arg2 ;
25089
25090   arg1 = (Dali::Gesture *)jarg1;
25091   arg2 = (Dali::Gesture::State)jarg2;
25092   if (arg1) (arg1)->state = arg2;
25093 }
25094
25095
25096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
25097   int jresult ;
25098   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
25099   Dali::Gesture::State result;
25100
25101   arg1 = (Dali::Gesture *)jarg1;
25102   result = (Dali::Gesture::State) ((arg1)->state);
25103   jresult = (int)result;
25104   return jresult;
25105 }
25106
25107
25108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
25109   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
25110   unsigned int arg2 ;
25111
25112   arg1 = (Dali::Gesture *)jarg1;
25113   arg2 = (unsigned int)jarg2;
25114   if (arg1) (arg1)->time = arg2;
25115 }
25116
25117
25118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
25119   unsigned int jresult ;
25120   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
25121   unsigned int result;
25122
25123   arg1 = (Dali::Gesture *)jarg1;
25124   result = (unsigned int) ((arg1)->time);
25125   jresult = result;
25126   return jresult;
25127 }
25128
25129
25130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_HoverEvent__SWIG_0() {
25131   void * jresult ;
25132   Dali::HoverEvent *result = 0 ;
25133
25134   {
25135     try {
25136       result = (Dali::HoverEvent *)new Dali::HoverEvent();
25137     } catch (std::out_of_range& e) {
25138       {
25139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25140       };
25141     } catch (std::exception& e) {
25142       {
25143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25144       };
25145     } catch (...) {
25146       {
25147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25148       };
25149     }
25150   }
25151   jresult = (void *)result;
25152   return jresult;
25153 }
25154
25155
25156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_HoverEvent__SWIG_1(unsigned long jarg1) {
25157   void * jresult ;
25158   unsigned long arg1 ;
25159   Dali::HoverEvent *result = 0 ;
25160
25161   arg1 = (unsigned long)jarg1;
25162   {
25163     try {
25164       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
25165     } catch (std::out_of_range& e) {
25166       {
25167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25168       };
25169     } catch (std::exception& e) {
25170       {
25171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25172       };
25173     } catch (...) {
25174       {
25175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25176       };
25177     }
25178   }
25179   jresult = (void *)result;
25180   return jresult;
25181 }
25182
25183
25184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_HoverEvent(void * jarg1) {
25185   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
25186
25187   arg1 = (Dali::HoverEvent *)jarg1;
25188   {
25189     try {
25190       delete arg1;
25191     } catch (std::out_of_range& e) {
25192       {
25193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25194       };
25195     } catch (std::exception& e) {
25196       {
25197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25198       };
25199     } catch (...) {
25200       {
25201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25202       };
25203     }
25204   }
25205 }
25206
25207
25208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_HoverEvent_points_set(void * jarg1, void * jarg2) {
25209   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
25210   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
25211
25212   arg1 = (Dali::HoverEvent *)jarg1;
25213   arg2 = (Dali::TouchPointContainer *)jarg2;
25214   if (arg1) (arg1)->points = *arg2;
25215 }
25216
25217
25218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HoverEvent_points_get(void * jarg1) {
25219   void * jresult ;
25220   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
25221   Dali::TouchPointContainer *result = 0 ;
25222
25223   arg1 = (Dali::HoverEvent *)jarg1;
25224   result = (Dali::TouchPointContainer *)& ((arg1)->points);
25225   jresult = (void *)result;
25226   return jresult;
25227 }
25228
25229
25230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_HoverEvent_time_set(void * jarg1, unsigned long jarg2) {
25231   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
25232   unsigned long arg2 ;
25233
25234   arg1 = (Dali::HoverEvent *)jarg1;
25235   arg2 = (unsigned long)jarg2;
25236   if (arg1) (arg1)->time = arg2;
25237 }
25238
25239
25240 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_HoverEvent_time_get(void * jarg1) {
25241   unsigned long jresult ;
25242   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
25243   unsigned long result;
25244
25245   arg1 = (Dali::HoverEvent *)jarg1;
25246   result = (unsigned long) ((arg1)->time);
25247   jresult = (unsigned long)result;
25248   return jresult;
25249 }
25250
25251
25252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HoverEvent_GetPointCount(void * jarg1) {
25253   unsigned int jresult ;
25254   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
25255   unsigned int result;
25256
25257   arg1 = (Dali::HoverEvent *)jarg1;
25258   {
25259     try {
25260       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
25261     } catch (std::out_of_range& e) {
25262       {
25263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25264       };
25265     } catch (std::exception& e) {
25266       {
25267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25268       };
25269     } catch (...) {
25270       {
25271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25272       };
25273     }
25274   }
25275   jresult = result;
25276   return jresult;
25277 }
25278
25279
25280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HoverEvent_GetPoint(void * jarg1, unsigned int jarg2) {
25281   void * jresult ;
25282   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
25283   unsigned int arg2 ;
25284   Dali::TouchPoint *result = 0 ;
25285
25286   arg1 = (Dali::HoverEvent *)jarg1;
25287   arg2 = (unsigned int)jarg2;
25288   {
25289     try {
25290       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
25291     } catch (std::out_of_range& e) {
25292       {
25293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25294       };
25295     } catch (std::exception& e) {
25296       {
25297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25298       };
25299     } catch (...) {
25300       {
25301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25302       };
25303     }
25304   }
25305   jresult = (void *)result;
25306   return jresult;
25307 }
25308
25309
25310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEvent__SWIG_0() {
25311   void * jresult ;
25312   Dali::KeyEvent *result = 0 ;
25313
25314   {
25315     try {
25316       result = (Dali::KeyEvent *)new Dali::KeyEvent();
25317     } catch (std::out_of_range& e) {
25318       {
25319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25320       };
25321     } catch (std::exception& e) {
25322       {
25323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25324       };
25325     } catch (...) {
25326       {
25327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25328       };
25329     }
25330   }
25331   jresult = (void *)result;
25332   return jresult;
25333 }
25334
25335
25336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEvent__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
25337   void * jresult ;
25338   std::string *arg1 = 0 ;
25339   std::string *arg2 = 0 ;
25340   int arg3 ;
25341   int arg4 ;
25342   unsigned long arg5 ;
25343   Dali::KeyEvent::State *arg6 = 0 ;
25344   Dali::KeyEvent::State temp6 ;
25345   Dali::KeyEvent *result = 0 ;
25346
25347   if (!jarg1) {
25348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
25349     return 0;
25350   }
25351   std::string arg1_str(jarg1);
25352   arg1 = &arg1_str;
25353   if (!jarg2) {
25354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
25355     return 0;
25356   }
25357   std::string arg2_str(jarg2);
25358   arg2 = &arg2_str;
25359   arg3 = (int)jarg3;
25360   arg4 = (int)jarg4;
25361   arg5 = (unsigned long)jarg5;
25362   temp6 = (Dali::KeyEvent::State)jarg6;
25363   arg6 = &temp6;
25364   {
25365     try {
25366       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
25367     } catch (std::out_of_range& e) {
25368       {
25369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25370       };
25371     } catch (std::exception& e) {
25372       {
25373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25374       };
25375     } catch (...) {
25376       {
25377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25378       };
25379     }
25380   }
25381   jresult = (void *)result;
25382
25383   //argout typemap for const std::string&
25384
25385
25386   //argout typemap for const std::string&
25387
25388   return jresult;
25389 }
25390
25391
25392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEvent(void * jarg1) {
25393   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25394
25395   arg1 = (Dali::KeyEvent *)jarg1;
25396   {
25397     try {
25398       delete arg1;
25399     } catch (std::out_of_range& e) {
25400       {
25401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25402       };
25403     } catch (std::exception& e) {
25404       {
25405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25406       };
25407     } catch (...) {
25408       {
25409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25410       };
25411     }
25412   }
25413 }
25414
25415
25416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEvent_IsShiftModifier(void * jarg1) {
25417   unsigned int jresult ;
25418   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25419   bool result;
25420
25421   arg1 = (Dali::KeyEvent *)jarg1;
25422   {
25423     try {
25424       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
25425     } catch (std::out_of_range& e) {
25426       {
25427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25428       };
25429     } catch (std::exception& e) {
25430       {
25431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25432       };
25433     } catch (...) {
25434       {
25435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25436       };
25437     }
25438   }
25439   jresult = result;
25440   return jresult;
25441 }
25442
25443
25444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEvent_IsCtrlModifier(void * jarg1) {
25445   unsigned int jresult ;
25446   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25447   bool result;
25448
25449   arg1 = (Dali::KeyEvent *)jarg1;
25450   {
25451     try {
25452       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
25453     } catch (std::out_of_range& e) {
25454       {
25455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25456       };
25457     } catch (std::exception& e) {
25458       {
25459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25460       };
25461     } catch (...) {
25462       {
25463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25464       };
25465     }
25466   }
25467   jresult = result;
25468   return jresult;
25469 }
25470
25471
25472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEvent_IsAltModifier(void * jarg1) {
25473   unsigned int jresult ;
25474   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25475   bool result;
25476
25477   arg1 = (Dali::KeyEvent *)jarg1;
25478   {
25479     try {
25480       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
25481     } catch (std::out_of_range& e) {
25482       {
25483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25484       };
25485     } catch (std::exception& e) {
25486       {
25487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25488       };
25489     } catch (...) {
25490       {
25491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25492       };
25493     }
25494   }
25495   jresult = result;
25496   return jresult;
25497 }
25498
25499
25500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEvent_keyPressedName_set(void * jarg1, char * jarg2) {
25501   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25502   std::string *arg2 = 0 ;
25503
25504   arg1 = (Dali::KeyEvent *)jarg1;
25505   if (!jarg2) {
25506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
25507     return ;
25508   }
25509   std::string arg2_str(jarg2);
25510   arg2 = &arg2_str;
25511   if (arg1) (arg1)->keyPressedName = *arg2;
25512
25513   //argout typemap for const std::string&
25514
25515 }
25516
25517
25518 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_KeyEvent_keyPressedName_get(void * jarg1) {
25519   char * jresult ;
25520   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25521   std::string *result = 0 ;
25522
25523   arg1 = (Dali::KeyEvent *)jarg1;
25524   result = (std::string *) & ((arg1)->keyPressedName);
25525   jresult = SWIG_csharp_string_callback(result->c_str());
25526   return jresult;
25527 }
25528
25529
25530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEvent_keyPressed_set(void * jarg1, char * jarg2) {
25531   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25532   std::string *arg2 = 0 ;
25533
25534   arg1 = (Dali::KeyEvent *)jarg1;
25535   if (!jarg2) {
25536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
25537     return ;
25538   }
25539   std::string arg2_str(jarg2);
25540   arg2 = &arg2_str;
25541   if (arg1) (arg1)->keyPressed = *arg2;
25542
25543   //argout typemap for const std::string&
25544
25545 }
25546
25547
25548 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_KeyEvent_keyPressed_get(void * jarg1) {
25549   char * jresult ;
25550   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25551   std::string *result = 0 ;
25552
25553   arg1 = (Dali::KeyEvent *)jarg1;
25554   result = (std::string *) & ((arg1)->keyPressed);
25555   jresult = SWIG_csharp_string_callback(result->c_str());
25556   return jresult;
25557 }
25558
25559
25560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEvent_keyCode_set(void * jarg1, int jarg2) {
25561   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25562   int arg2 ;
25563
25564   arg1 = (Dali::KeyEvent *)jarg1;
25565   arg2 = (int)jarg2;
25566   if (arg1) (arg1)->keyCode = arg2;
25567 }
25568
25569
25570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyEvent_keyCode_get(void * jarg1) {
25571   int jresult ;
25572   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25573   int result;
25574
25575   arg1 = (Dali::KeyEvent *)jarg1;
25576   result = (int) ((arg1)->keyCode);
25577   jresult = result;
25578   return jresult;
25579 }
25580
25581
25582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEvent_keyModifier_set(void * jarg1, int jarg2) {
25583   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25584   int arg2 ;
25585
25586   arg1 = (Dali::KeyEvent *)jarg1;
25587   arg2 = (int)jarg2;
25588   if (arg1) (arg1)->keyModifier = arg2;
25589 }
25590
25591
25592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyEvent_keyModifier_get(void * jarg1) {
25593   int jresult ;
25594   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25595   int result;
25596
25597   arg1 = (Dali::KeyEvent *)jarg1;
25598   result = (int) ((arg1)->keyModifier);
25599   jresult = result;
25600   return jresult;
25601 }
25602
25603
25604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEvent_time_set(void * jarg1, unsigned long jarg2) {
25605   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25606   unsigned long arg2 ;
25607
25608   arg1 = (Dali::KeyEvent *)jarg1;
25609   arg2 = (unsigned long)jarg2;
25610   if (arg1) (arg1)->time = arg2;
25611 }
25612
25613
25614 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEvent_time_get(void * jarg1) {
25615   unsigned long jresult ;
25616   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25617   unsigned long result;
25618
25619   arg1 = (Dali::KeyEvent *)jarg1;
25620   result = (unsigned long) ((arg1)->time);
25621   jresult = (unsigned long)result;
25622   return jresult;
25623 }
25624
25625
25626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEvent_state_set(void * jarg1, int jarg2) {
25627   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25628   Dali::KeyEvent::State arg2 ;
25629
25630   arg1 = (Dali::KeyEvent *)jarg1;
25631   arg2 = (Dali::KeyEvent::State)jarg2;
25632   if (arg1) (arg1)->state = arg2;
25633 }
25634
25635
25636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyEvent_state_get(void * jarg1) {
25637   int jresult ;
25638   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
25639   Dali::KeyEvent::State result;
25640
25641   arg1 = (Dali::KeyEvent *)jarg1;
25642   result = (Dali::KeyEvent::State) ((arg1)->state);
25643   jresult = (int)result;
25644   return jresult;
25645 }
25646
25647
25648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
25649   void * jresult ;
25650   Dali::LongPressGestureDetector *result = 0 ;
25651
25652   {
25653     try {
25654       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
25655     } catch (std::out_of_range& e) {
25656       {
25657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25658       };
25659     } catch (std::exception& e) {
25660       {
25661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25662       };
25663     } catch (...) {
25664       {
25665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25666       };
25667     }
25668   }
25669   jresult = (void *)result;
25670   return jresult;
25671 }
25672
25673
25674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
25675   void * jresult ;
25676   Dali::LongPressGestureDetector result;
25677
25678   {
25679     try {
25680       result = Dali::LongPressGestureDetector::New();
25681     } catch (std::out_of_range& e) {
25682       {
25683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25684       };
25685     } catch (std::exception& e) {
25686       {
25687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25688       };
25689     } catch (...) {
25690       {
25691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25692       };
25693     }
25694   }
25695   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
25696   return jresult;
25697 }
25698
25699
25700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
25701   void * jresult ;
25702   unsigned int arg1 ;
25703   Dali::LongPressGestureDetector result;
25704
25705   arg1 = (unsigned int)jarg1;
25706   {
25707     try {
25708       result = Dali::LongPressGestureDetector::New(arg1);
25709     } catch (std::out_of_range& e) {
25710       {
25711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25712       };
25713     } catch (std::exception& e) {
25714       {
25715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25716       };
25717     } catch (...) {
25718       {
25719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25720       };
25721     }
25722   }
25723   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
25724   return jresult;
25725 }
25726
25727
25728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
25729   void * jresult ;
25730   unsigned int arg1 ;
25731   unsigned int arg2 ;
25732   Dali::LongPressGestureDetector result;
25733
25734   arg1 = (unsigned int)jarg1;
25735   arg2 = (unsigned int)jarg2;
25736   {
25737     try {
25738       result = Dali::LongPressGestureDetector::New(arg1,arg2);
25739     } catch (std::out_of_range& e) {
25740       {
25741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25742       };
25743     } catch (std::exception& e) {
25744       {
25745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25746       };
25747     } catch (...) {
25748       {
25749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25750       };
25751     }
25752   }
25753   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
25754   return jresult;
25755 }
25756
25757
25758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
25759   void * jresult ;
25760   Dali::BaseHandle arg1 ;
25761   Dali::BaseHandle *argp1 ;
25762   Dali::LongPressGestureDetector result;
25763
25764   argp1 = (Dali::BaseHandle *)jarg1;
25765   if (!argp1) {
25766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25767     return 0;
25768   }
25769   arg1 = *argp1;
25770   {
25771     try {
25772       result = Dali::LongPressGestureDetector::DownCast(arg1);
25773     } catch (std::out_of_range& e) {
25774       {
25775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25776       };
25777     } catch (std::exception& e) {
25778       {
25779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25780       };
25781     } catch (...) {
25782       {
25783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25784       };
25785     }
25786   }
25787   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
25788   return jresult;
25789 }
25790
25791
25792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
25793   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
25794
25795   arg1 = (Dali::LongPressGestureDetector *)jarg1;
25796   {
25797     try {
25798       delete arg1;
25799     } catch (std::out_of_range& e) {
25800       {
25801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25802       };
25803     } catch (std::exception& e) {
25804       {
25805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25806       };
25807     } catch (...) {
25808       {
25809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25810       };
25811     }
25812   }
25813 }
25814
25815
25816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
25817   void * jresult ;
25818   Dali::LongPressGestureDetector *arg1 = 0 ;
25819   Dali::LongPressGestureDetector *result = 0 ;
25820
25821   arg1 = (Dali::LongPressGestureDetector *)jarg1;
25822   if (!arg1) {
25823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
25824     return 0;
25825   }
25826   {
25827     try {
25828       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
25829     } catch (std::out_of_range& e) {
25830       {
25831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25832       };
25833     } catch (std::exception& e) {
25834       {
25835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25836       };
25837     } catch (...) {
25838       {
25839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25840       };
25841     }
25842   }
25843   jresult = (void *)result;
25844   return jresult;
25845 }
25846
25847
25848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
25849   void * jresult ;
25850   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
25851   Dali::LongPressGestureDetector *arg2 = 0 ;
25852   Dali::LongPressGestureDetector *result = 0 ;
25853
25854   arg1 = (Dali::LongPressGestureDetector *)jarg1;
25855   arg2 = (Dali::LongPressGestureDetector *)jarg2;
25856   if (!arg2) {
25857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
25858     return 0;
25859   }
25860   {
25861     try {
25862       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
25863     } catch (std::out_of_range& e) {
25864       {
25865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25866       };
25867     } catch (std::exception& e) {
25868       {
25869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25870       };
25871     } catch (...) {
25872       {
25873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25874       };
25875     }
25876   }
25877   jresult = (void *)result;
25878   return jresult;
25879 }
25880
25881
25882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
25883   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
25884   unsigned int arg2 ;
25885
25886   arg1 = (Dali::LongPressGestureDetector *)jarg1;
25887   arg2 = (unsigned int)jarg2;
25888   {
25889     try {
25890       (arg1)->SetTouchesRequired(arg2);
25891     } catch (std::out_of_range& e) {
25892       {
25893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25894       };
25895     } catch (std::exception& e) {
25896       {
25897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25898       };
25899     } catch (...) {
25900       {
25901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25902       };
25903     }
25904   }
25905 }
25906
25907
25908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
25909   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
25910   unsigned int arg2 ;
25911   unsigned int arg3 ;
25912
25913   arg1 = (Dali::LongPressGestureDetector *)jarg1;
25914   arg2 = (unsigned int)jarg2;
25915   arg3 = (unsigned int)jarg3;
25916   {
25917     try {
25918       (arg1)->SetTouchesRequired(arg2,arg3);
25919     } catch (std::out_of_range& e) {
25920       {
25921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25922       };
25923     } catch (std::exception& e) {
25924       {
25925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25926       };
25927     } catch (...) {
25928       {
25929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25930       };
25931     }
25932   }
25933 }
25934
25935
25936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
25937   unsigned int jresult ;
25938   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
25939   unsigned int result;
25940
25941   arg1 = (Dali::LongPressGestureDetector *)jarg1;
25942   {
25943     try {
25944       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
25945     } catch (std::out_of_range& e) {
25946       {
25947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25948       };
25949     } catch (std::exception& e) {
25950       {
25951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25952       };
25953     } catch (...) {
25954       {
25955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25956       };
25957     }
25958   }
25959   jresult = result;
25960   return jresult;
25961 }
25962
25963
25964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
25965   unsigned int jresult ;
25966   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
25967   unsigned int result;
25968
25969   arg1 = (Dali::LongPressGestureDetector *)jarg1;
25970   {
25971     try {
25972       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
25973     } catch (std::out_of_range& e) {
25974       {
25975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25976       };
25977     } catch (std::exception& e) {
25978       {
25979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25980       };
25981     } catch (...) {
25982       {
25983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25984       };
25985     }
25986   }
25987   jresult = result;
25988   return jresult;
25989 }
25990
25991
25992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
25993   void * jresult ;
25994   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
25995   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
25996
25997   arg1 = (Dali::LongPressGestureDetector *)jarg1;
25998   {
25999     try {
26000       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26001     } catch (std::out_of_range& e) {
26002       {
26003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26004       };
26005     } catch (std::exception& e) {
26006       {
26007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26008       };
26009     } catch (...) {
26010       {
26011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26012       };
26013     }
26014   }
26015   jresult = (void *)result;
26016   return jresult;
26017 }
26018
26019
26020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
26021   void * jresult ;
26022   Dali::Gesture::State arg1 ;
26023   Dali::LongPressGesture *result = 0 ;
26024
26025   arg1 = (Dali::Gesture::State)jarg1;
26026   {
26027     try {
26028       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
26029     } catch (std::out_of_range& e) {
26030       {
26031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26032       };
26033     } catch (std::exception& e) {
26034       {
26035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26036       };
26037     } catch (...) {
26038       {
26039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26040       };
26041     }
26042   }
26043   jresult = (void *)result;
26044   return jresult;
26045 }
26046
26047
26048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
26049   void * jresult ;
26050   Dali::LongPressGesture *arg1 = 0 ;
26051   Dali::LongPressGesture *result = 0 ;
26052
26053   arg1 = (Dali::LongPressGesture *)jarg1;
26054   if (!arg1) {
26055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
26056     return 0;
26057   }
26058   {
26059     try {
26060       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
26061     } catch (std::out_of_range& e) {
26062       {
26063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26064       };
26065     } catch (std::exception& e) {
26066       {
26067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26068       };
26069     } catch (...) {
26070       {
26071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26072       };
26073     }
26074   }
26075   jresult = (void *)result;
26076   return jresult;
26077 }
26078
26079
26080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
26081   void * jresult ;
26082   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
26083   Dali::LongPressGesture *arg2 = 0 ;
26084   Dali::LongPressGesture *result = 0 ;
26085
26086   arg1 = (Dali::LongPressGesture *)jarg1;
26087   arg2 = (Dali::LongPressGesture *)jarg2;
26088   if (!arg2) {
26089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
26090     return 0;
26091   }
26092   {
26093     try {
26094       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
26095     } catch (std::out_of_range& e) {
26096       {
26097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26098       };
26099     } catch (std::exception& e) {
26100       {
26101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26102       };
26103     } catch (...) {
26104       {
26105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26106       };
26107     }
26108   }
26109   jresult = (void *)result;
26110   return jresult;
26111 }
26112
26113
26114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
26115   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
26116
26117   arg1 = (Dali::LongPressGesture *)jarg1;
26118   {
26119     try {
26120       delete arg1;
26121     } catch (std::out_of_range& e) {
26122       {
26123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26124       };
26125     } catch (std::exception& e) {
26126       {
26127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26128       };
26129     } catch (...) {
26130       {
26131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26132       };
26133     }
26134   }
26135 }
26136
26137
26138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
26139   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
26140   unsigned int arg2 ;
26141
26142   arg1 = (Dali::LongPressGesture *)jarg1;
26143   arg2 = (unsigned int)jarg2;
26144   if (arg1) (arg1)->numberOfTouches = arg2;
26145 }
26146
26147
26148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
26149   unsigned int jresult ;
26150   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
26151   unsigned int result;
26152
26153   arg1 = (Dali::LongPressGesture *)jarg1;
26154   result = (unsigned int) ((arg1)->numberOfTouches);
26155   jresult = result;
26156   return jresult;
26157 }
26158
26159
26160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
26161   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
26162   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26163
26164   arg1 = (Dali::LongPressGesture *)jarg1;
26165   arg2 = (Dali::Vector2 *)jarg2;
26166   if (arg1) (arg1)->screenPoint = *arg2;
26167 }
26168
26169
26170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
26171   void * jresult ;
26172   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
26173   Dali::Vector2 *result = 0 ;
26174
26175   arg1 = (Dali::LongPressGesture *)jarg1;
26176   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
26177   jresult = (void *)result;
26178   return jresult;
26179 }
26180
26181
26182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
26183   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
26184   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26185
26186   arg1 = (Dali::LongPressGesture *)jarg1;
26187   arg2 = (Dali::Vector2 *)jarg2;
26188   if (arg1) (arg1)->localPoint = *arg2;
26189 }
26190
26191
26192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
26193   void * jresult ;
26194   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
26195   Dali::Vector2 *result = 0 ;
26196
26197   arg1 = (Dali::LongPressGesture *)jarg1;
26198   result = (Dali::Vector2 *)& ((arg1)->localPoint);
26199   jresult = (void *)result;
26200   return jresult;
26201 }
26202
26203
26204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WheelEvent__SWIG_0() {
26205   void * jresult ;
26206   Dali::WheelEvent *result = 0 ;
26207
26208   {
26209     try {
26210       result = (Dali::WheelEvent *)new Dali::WheelEvent();
26211     } catch (std::out_of_range& e) {
26212       {
26213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26214       };
26215     } catch (std::exception& e) {
26216       {
26217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26218       };
26219     } catch (...) {
26220       {
26221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26222       };
26223     }
26224   }
26225   jresult = (void *)result;
26226   return jresult;
26227 }
26228
26229
26230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WheelEvent__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
26231   void * jresult ;
26232   Dali::WheelEvent::Type arg1 ;
26233   int arg2 ;
26234   unsigned int arg3 ;
26235   Dali::Vector2 arg4 ;
26236   int arg5 ;
26237   unsigned int arg6 ;
26238   Dali::Vector2 *argp4 ;
26239   Dali::WheelEvent *result = 0 ;
26240
26241   arg1 = (Dali::WheelEvent::Type)jarg1;
26242   arg2 = (int)jarg2;
26243   arg3 = (unsigned int)jarg3;
26244   argp4 = (Dali::Vector2 *)jarg4;
26245   if (!argp4) {
26246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
26247     return 0;
26248   }
26249   arg4 = *argp4;
26250   arg5 = (int)jarg5;
26251   arg6 = (unsigned int)jarg6;
26252   {
26253     try {
26254       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
26255     } catch (std::out_of_range& e) {
26256       {
26257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26258       };
26259     } catch (std::exception& e) {
26260       {
26261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26262       };
26263     } catch (...) {
26264       {
26265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26266       };
26267     }
26268   }
26269   jresult = (void *)result;
26270   return jresult;
26271 }
26272
26273
26274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WheelEvent(void * jarg1) {
26275   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26276
26277   arg1 = (Dali::WheelEvent *)jarg1;
26278   {
26279     try {
26280       delete arg1;
26281     } catch (std::out_of_range& e) {
26282       {
26283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26284       };
26285     } catch (std::exception& e) {
26286       {
26287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26288       };
26289     } catch (...) {
26290       {
26291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26292       };
26293     }
26294   }
26295 }
26296
26297
26298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WheelEvent_IsShiftModifier(void * jarg1) {
26299   unsigned int jresult ;
26300   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26301   bool result;
26302
26303   arg1 = (Dali::WheelEvent *)jarg1;
26304   {
26305     try {
26306       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
26307     } catch (std::out_of_range& e) {
26308       {
26309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26310       };
26311     } catch (std::exception& e) {
26312       {
26313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26314       };
26315     } catch (...) {
26316       {
26317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26318       };
26319     }
26320   }
26321   jresult = result;
26322   return jresult;
26323 }
26324
26325
26326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WheelEvent_IsCtrlModifier(void * jarg1) {
26327   unsigned int jresult ;
26328   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26329   bool result;
26330
26331   arg1 = (Dali::WheelEvent *)jarg1;
26332   {
26333     try {
26334       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
26335     } catch (std::out_of_range& e) {
26336       {
26337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26338       };
26339     } catch (std::exception& e) {
26340       {
26341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26342       };
26343     } catch (...) {
26344       {
26345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26346       };
26347     }
26348   }
26349   jresult = result;
26350   return jresult;
26351 }
26352
26353
26354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WheelEvent_IsAltModifier(void * jarg1) {
26355   unsigned int jresult ;
26356   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26357   bool result;
26358
26359   arg1 = (Dali::WheelEvent *)jarg1;
26360   {
26361     try {
26362       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
26363     } catch (std::out_of_range& e) {
26364       {
26365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26366       };
26367     } catch (std::exception& e) {
26368       {
26369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26370       };
26371     } catch (...) {
26372       {
26373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26374       };
26375     }
26376   }
26377   jresult = result;
26378   return jresult;
26379 }
26380
26381
26382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WheelEvent_type_set(void * jarg1, int jarg2) {
26383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26384   Dali::WheelEvent::Type arg2 ;
26385
26386   arg1 = (Dali::WheelEvent *)jarg1;
26387   arg2 = (Dali::WheelEvent::Type)jarg2;
26388   if (arg1) (arg1)->type = arg2;
26389 }
26390
26391
26392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WheelEvent_type_get(void * jarg1) {
26393   int jresult ;
26394   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26395   Dali::WheelEvent::Type result;
26396
26397   arg1 = (Dali::WheelEvent *)jarg1;
26398   result = (Dali::WheelEvent::Type) ((arg1)->type);
26399   jresult = (int)result;
26400   return jresult;
26401 }
26402
26403
26404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WheelEvent_direction_set(void * jarg1, int jarg2) {
26405   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26406   int arg2 ;
26407
26408   arg1 = (Dali::WheelEvent *)jarg1;
26409   arg2 = (int)jarg2;
26410   if (arg1) (arg1)->direction = arg2;
26411 }
26412
26413
26414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WheelEvent_direction_get(void * jarg1) {
26415   int jresult ;
26416   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26417   int result;
26418
26419   arg1 = (Dali::WheelEvent *)jarg1;
26420   result = (int) ((arg1)->direction);
26421   jresult = result;
26422   return jresult;
26423 }
26424
26425
26426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WheelEvent_modifiers_set(void * jarg1, unsigned int jarg2) {
26427   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26428   unsigned int arg2 ;
26429
26430   arg1 = (Dali::WheelEvent *)jarg1;
26431   arg2 = (unsigned int)jarg2;
26432   if (arg1) (arg1)->modifiers = arg2;
26433 }
26434
26435
26436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WheelEvent_modifiers_get(void * jarg1) {
26437   unsigned int jresult ;
26438   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26439   unsigned int result;
26440
26441   arg1 = (Dali::WheelEvent *)jarg1;
26442   result = (unsigned int) ((arg1)->modifiers);
26443   jresult = result;
26444   return jresult;
26445 }
26446
26447
26448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WheelEvent_point_set(void * jarg1, void * jarg2) {
26449   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26450   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26451
26452   arg1 = (Dali::WheelEvent *)jarg1;
26453   arg2 = (Dali::Vector2 *)jarg2;
26454   if (arg1) (arg1)->point = *arg2;
26455 }
26456
26457
26458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WheelEvent_point_get(void * jarg1) {
26459   void * jresult ;
26460   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26461   Dali::Vector2 *result = 0 ;
26462
26463   arg1 = (Dali::WheelEvent *)jarg1;
26464   result = (Dali::Vector2 *)& ((arg1)->point);
26465   jresult = (void *)result;
26466   return jresult;
26467 }
26468
26469
26470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WheelEvent_z_set(void * jarg1, int jarg2) {
26471   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26472   int arg2 ;
26473
26474   arg1 = (Dali::WheelEvent *)jarg1;
26475   arg2 = (int)jarg2;
26476   if (arg1) (arg1)->z = arg2;
26477 }
26478
26479
26480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WheelEvent_z_get(void * jarg1) {
26481   int jresult ;
26482   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26483   int result;
26484
26485   arg1 = (Dali::WheelEvent *)jarg1;
26486   result = (int) ((arg1)->z);
26487   jresult = result;
26488   return jresult;
26489 }
26490
26491
26492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WheelEvent_timeStamp_set(void * jarg1, unsigned int jarg2) {
26493   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26494   unsigned int arg2 ;
26495
26496   arg1 = (Dali::WheelEvent *)jarg1;
26497   arg2 = (unsigned int)jarg2;
26498   if (arg1) (arg1)->timeStamp = arg2;
26499 }
26500
26501
26502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WheelEvent_timeStamp_get(void * jarg1) {
26503   unsigned int jresult ;
26504   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
26505   unsigned int result;
26506
26507   arg1 = (Dali::WheelEvent *)jarg1;
26508   result = (unsigned int) ((arg1)->timeStamp);
26509   jresult = result;
26510   return jresult;
26511 }
26512
26513
26514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
26515   int jresult ;
26516   int result;
26517
26518   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
26519   jresult = (int)result;
26520   return jresult;
26521 }
26522
26523
26524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
26525   int jresult ;
26526   int result;
26527
26528   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
26529   jresult = (int)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
26535   int jresult ;
26536   int result;
26537
26538   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
26539   jresult = (int)result;
26540   return jresult;
26541 }
26542
26543
26544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
26545   int jresult ;
26546   int result;
26547
26548   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
26549   jresult = (int)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
26555   int jresult ;
26556   int result;
26557
26558   result = (int)Dali::Actor::Property::ANCHOR_POINT;
26559   jresult = (int)result;
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
26565   int jresult ;
26566   int result;
26567
26568   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
26569   jresult = (int)result;
26570   return jresult;
26571 }
26572
26573
26574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
26575   int jresult ;
26576   int result;
26577
26578   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
26579   jresult = (int)result;
26580   return jresult;
26581 }
26582
26583
26584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
26585   int jresult ;
26586   int result;
26587
26588   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
26589   jresult = (int)result;
26590   return jresult;
26591 }
26592
26593
26594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
26595   int jresult ;
26596   int result;
26597
26598   result = (int)Dali::Actor::Property::SIZE;
26599   jresult = (int)result;
26600   return jresult;
26601 }
26602
26603
26604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
26605   int jresult ;
26606   int result;
26607
26608   result = (int)Dali::Actor::Property::SIZE_WIDTH;
26609   jresult = (int)result;
26610   return jresult;
26611 }
26612
26613
26614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
26615   int jresult ;
26616   int result;
26617
26618   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
26619   jresult = (int)result;
26620   return jresult;
26621 }
26622
26623
26624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
26625   int jresult ;
26626   int result;
26627
26628   result = (int)Dali::Actor::Property::SIZE_DEPTH;
26629   jresult = (int)result;
26630   return jresult;
26631 }
26632
26633
26634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
26635   int jresult ;
26636   int result;
26637
26638   result = (int)Dali::Actor::Property::POSITION;
26639   jresult = (int)result;
26640   return jresult;
26641 }
26642
26643
26644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
26645   int jresult ;
26646   int result;
26647
26648   result = (int)Dali::Actor::Property::POSITION_X;
26649   jresult = (int)result;
26650   return jresult;
26651 }
26652
26653
26654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
26655   int jresult ;
26656   int result;
26657
26658   result = (int)Dali::Actor::Property::POSITION_Y;
26659   jresult = (int)result;
26660   return jresult;
26661 }
26662
26663
26664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
26665   int jresult ;
26666   int result;
26667
26668   result = (int)Dali::Actor::Property::POSITION_Z;
26669   jresult = (int)result;
26670   return jresult;
26671 }
26672
26673
26674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
26675   int jresult ;
26676   int result;
26677
26678   result = (int)Dali::Actor::Property::WORLD_POSITION;
26679   jresult = (int)result;
26680   return jresult;
26681 }
26682
26683
26684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
26685   int jresult ;
26686   int result;
26687
26688   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
26689   jresult = (int)result;
26690   return jresult;
26691 }
26692
26693
26694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
26695   int jresult ;
26696   int result;
26697
26698   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
26699   jresult = (int)result;
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
26705   int jresult ;
26706   int result;
26707
26708   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
26709   jresult = (int)result;
26710   return jresult;
26711 }
26712
26713
26714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
26715   int jresult ;
26716   int result;
26717
26718   result = (int)Dali::Actor::Property::ORIENTATION;
26719   jresult = (int)result;
26720   return jresult;
26721 }
26722
26723
26724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
26725   int jresult ;
26726   int result;
26727
26728   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
26729   jresult = (int)result;
26730   return jresult;
26731 }
26732
26733
26734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
26735   int jresult ;
26736   int result;
26737
26738   result = (int)Dali::Actor::Property::SCALE;
26739   jresult = (int)result;
26740   return jresult;
26741 }
26742
26743
26744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
26745   int jresult ;
26746   int result;
26747
26748   result = (int)Dali::Actor::Property::SCALE_X;
26749   jresult = (int)result;
26750   return jresult;
26751 }
26752
26753
26754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
26755   int jresult ;
26756   int result;
26757
26758   result = (int)Dali::Actor::Property::SCALE_Y;
26759   jresult = (int)result;
26760   return jresult;
26761 }
26762
26763
26764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
26765   int jresult ;
26766   int result;
26767
26768   result = (int)Dali::Actor::Property::SCALE_Z;
26769   jresult = (int)result;
26770   return jresult;
26771 }
26772
26773
26774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
26775   int jresult ;
26776   int result;
26777
26778   result = (int)Dali::Actor::Property::WORLD_SCALE;
26779   jresult = (int)result;
26780   return jresult;
26781 }
26782
26783
26784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
26785   int jresult ;
26786   int result;
26787
26788   result = (int)Dali::Actor::Property::VISIBLE;
26789   jresult = (int)result;
26790   return jresult;
26791 }
26792
26793
26794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
26795   int jresult ;
26796   int result;
26797
26798   result = (int)Dali::Actor::Property::COLOR;
26799   jresult = (int)result;
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
26805   int jresult ;
26806   int result;
26807
26808   result = (int)Dali::Actor::Property::COLOR_RED;
26809   jresult = (int)result;
26810   return jresult;
26811 }
26812
26813
26814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
26815   int jresult ;
26816   int result;
26817
26818   result = (int)Dali::Actor::Property::COLOR_GREEN;
26819   jresult = (int)result;
26820   return jresult;
26821 }
26822
26823
26824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
26825   int jresult ;
26826   int result;
26827
26828   result = (int)Dali::Actor::Property::COLOR_BLUE;
26829   jresult = (int)result;
26830   return jresult;
26831 }
26832
26833
26834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
26835   int jresult ;
26836   int result;
26837
26838   result = (int)Dali::Actor::Property::COLOR_ALPHA;
26839   jresult = (int)result;
26840   return jresult;
26841 }
26842
26843
26844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
26845   int jresult ;
26846   int result;
26847
26848   result = (int)Dali::Actor::Property::WORLD_COLOR;
26849   jresult = (int)result;
26850   return jresult;
26851 }
26852
26853
26854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
26855   int jresult ;
26856   int result;
26857
26858   result = (int)Dali::Actor::Property::WORLD_MATRIX;
26859   jresult = (int)result;
26860   return jresult;
26861 }
26862
26863
26864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
26865   int jresult ;
26866   int result;
26867
26868   result = (int)Dali::Actor::Property::NAME;
26869   jresult = (int)result;
26870   return jresult;
26871 }
26872
26873
26874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
26875   int jresult ;
26876   int result;
26877
26878   result = (int)Dali::Actor::Property::SENSITIVE;
26879   jresult = (int)result;
26880   return jresult;
26881 }
26882
26883
26884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
26885   int jresult ;
26886   int result;
26887
26888   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
26889   jresult = (int)result;
26890   return jresult;
26891 }
26892
26893
26894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
26895   int jresult ;
26896   int result;
26897
26898   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
26899   jresult = (int)result;
26900   return jresult;
26901 }
26902
26903
26904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
26905   int jresult ;
26906   int result;
26907
26908   result = (int)Dali::Actor::Property::INHERIT_SCALE;
26909   jresult = (int)result;
26910   return jresult;
26911 }
26912
26913
26914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
26915   int jresult ;
26916   int result;
26917
26918   result = (int)Dali::Actor::Property::COLOR_MODE;
26919   jresult = (int)result;
26920   return jresult;
26921 }
26922
26923
26924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
26925   int jresult ;
26926   int result;
26927
26928   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
26929   jresult = (int)result;
26930   return jresult;
26931 }
26932
26933
26934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
26935   int jresult ;
26936   int result;
26937
26938   result = (int)Dali::Actor::Property::DRAW_MODE;
26939   jresult = (int)result;
26940   return jresult;
26941 }
26942
26943
26944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
26945   int jresult ;
26946   int result;
26947
26948   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
26949   jresult = (int)result;
26950   return jresult;
26951 }
26952
26953
26954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
26955   int jresult ;
26956   int result;
26957
26958   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
26959   jresult = (int)result;
26960   return jresult;
26961 }
26962
26963
26964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
26965   int jresult ;
26966   int result;
26967
26968   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
26969   jresult = (int)result;
26970   return jresult;
26971 }
26972
26973
26974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
26975   int jresult ;
26976   int result;
26977
26978   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
26979   jresult = (int)result;
26980   return jresult;
26981 }
26982
26983
26984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
26985   int jresult ;
26986   int result;
26987
26988   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
26989   jresult = (int)result;
26990   return jresult;
26991 }
26992
26993
26994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
26995   int jresult ;
26996   int result;
26997
26998   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
26999   jresult = (int)result;
27000   return jresult;
27001 }
27002
27003
27004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
27005   int jresult ;
27006   int result;
27007
27008   result = (int)Dali::Actor::Property::PADDING;
27009   jresult = (int)result;
27010   return jresult;
27011 }
27012
27013
27014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
27015   int jresult ;
27016   int result;
27017
27018   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
27019   jresult = (int)result;
27020   return jresult;
27021 }
27022
27023
27024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
27025   int jresult ;
27026   int result;
27027
27028   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
27029   jresult = (int)result;
27030   return jresult;
27031 }
27032
27033
27034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
27035   int jresult ;
27036   int result;
27037
27038   result = (int)Dali::Actor::Property::INHERIT_POSITION;
27039   jresult = (int)result;
27040   return jresult;
27041 }
27042
27043
27044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
27045   int jresult ;
27046   int result;
27047
27048   result = (int)Dali::Actor::Property::CLIPPING_MODE;
27049   jresult = (int)result;
27050   return jresult;
27051 }
27052
27053
27054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_BATCH_PARENT_get() {
27055   int jresult ;
27056   int result;
27057
27058   result = (int)Dali::Actor::Property::BATCH_PARENT;
27059   jresult = (int)result;
27060   return jresult;
27061 }
27062
27063
27064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
27065   void * jresult ;
27066   Dali::Actor::Property *result = 0 ;
27067
27068   {
27069     try {
27070       result = (Dali::Actor::Property *)new Dali::Actor::Property();
27071     } catch (std::out_of_range& e) {
27072       {
27073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27074       };
27075     } catch (std::exception& e) {
27076       {
27077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27078       };
27079     } catch (...) {
27080       {
27081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27082       };
27083     }
27084   }
27085   jresult = (void *)result;
27086   return jresult;
27087 }
27088
27089
27090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
27091   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
27092
27093   arg1 = (Dali::Actor::Property *)jarg1;
27094   {
27095     try {
27096       delete arg1;
27097     } catch (std::out_of_range& e) {
27098       {
27099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27100       };
27101     } catch (std::exception& e) {
27102       {
27103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27104       };
27105     } catch (...) {
27106       {
27107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27108       };
27109     }
27110   }
27111 }
27112
27113
27114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
27115   void * jresult ;
27116   Dali::Actor *result = 0 ;
27117
27118   {
27119     try {
27120       result = (Dali::Actor *)new Dali::Actor();
27121     } catch (std::out_of_range& e) {
27122       {
27123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27124       };
27125     } catch (std::exception& e) {
27126       {
27127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27128       };
27129     } catch (...) {
27130       {
27131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27132       };
27133     }
27134   }
27135   jresult = (void *)result;
27136   return jresult;
27137 }
27138
27139
27140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
27141   void * jresult ;
27142   Dali::Actor result;
27143
27144   {
27145     try {
27146       result = Dali::Actor::New();
27147     } catch (std::out_of_range& e) {
27148       {
27149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27150       };
27151     } catch (std::exception& e) {
27152       {
27153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27154       };
27155     } catch (...) {
27156       {
27157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27158       };
27159     }
27160   }
27161   jresult = new Dali::Actor((const Dali::Actor &)result);
27162   return jresult;
27163 }
27164
27165
27166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
27167   void * jresult ;
27168   Dali::BaseHandle arg1 ;
27169   Dali::BaseHandle *argp1 ;
27170   Dali::Actor result;
27171
27172   argp1 = (Dali::BaseHandle *)jarg1;
27173   if (!argp1) {
27174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27175     return 0;
27176   }
27177   arg1 = *argp1;
27178   {
27179     try {
27180       result = Dali::Actor::DownCast(arg1);
27181     } catch (std::out_of_range& e) {
27182       {
27183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27184       };
27185     } catch (std::exception& e) {
27186       {
27187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27188       };
27189     } catch (...) {
27190       {
27191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27192       };
27193     }
27194   }
27195   jresult = new Dali::Actor((const Dali::Actor &)result);
27196   return jresult;
27197 }
27198
27199
27200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
27201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27202
27203   arg1 = (Dali::Actor *)jarg1;
27204   {
27205     try {
27206       delete arg1;
27207     } catch (std::out_of_range& e) {
27208       {
27209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27210       };
27211     } catch (std::exception& e) {
27212       {
27213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27214       };
27215     } catch (...) {
27216       {
27217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27218       };
27219     }
27220   }
27221 }
27222
27223
27224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
27225   void * jresult ;
27226   Dali::Actor *arg1 = 0 ;
27227   Dali::Actor *result = 0 ;
27228
27229   arg1 = (Dali::Actor *)jarg1;
27230   if (!arg1) {
27231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27232     return 0;
27233   }
27234   {
27235     try {
27236       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
27237     } catch (std::out_of_range& e) {
27238       {
27239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27240       };
27241     } catch (std::exception& e) {
27242       {
27243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27244       };
27245     } catch (...) {
27246       {
27247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27248       };
27249     }
27250   }
27251   jresult = (void *)result;
27252   return jresult;
27253 }
27254
27255
27256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
27257   void * jresult ;
27258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27259   Dali::Actor *arg2 = 0 ;
27260   Dali::Actor *result = 0 ;
27261
27262   arg1 = (Dali::Actor *)jarg1;
27263   arg2 = (Dali::Actor *)jarg2;
27264   if (!arg2) {
27265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27266     return 0;
27267   }
27268   {
27269     try {
27270       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
27271     } catch (std::out_of_range& e) {
27272       {
27273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27274       };
27275     } catch (std::exception& e) {
27276       {
27277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27278       };
27279     } catch (...) {
27280       {
27281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27282       };
27283     }
27284   }
27285   jresult = (void *)result;
27286   return jresult;
27287 }
27288
27289
27290 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
27291   char * jresult ;
27292   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27293   std::string *result = 0 ;
27294
27295   arg1 = (Dali::Actor *)jarg1;
27296   {
27297     try {
27298       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
27299     } catch (std::out_of_range& e) {
27300       {
27301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27302       };
27303     } catch (std::exception& e) {
27304       {
27305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27306       };
27307     } catch (...) {
27308       {
27309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27310       };
27311     }
27312   }
27313   jresult = SWIG_csharp_string_callback(result->c_str());
27314   return jresult;
27315 }
27316
27317
27318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
27319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27320   std::string *arg2 = 0 ;
27321
27322   arg1 = (Dali::Actor *)jarg1;
27323   if (!jarg2) {
27324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27325     return ;
27326   }
27327   std::string arg2_str(jarg2);
27328   arg2 = &arg2_str;
27329   {
27330     try {
27331       (arg1)->SetName((std::string const &)*arg2);
27332     } catch (std::out_of_range& e) {
27333       {
27334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27335       };
27336     } catch (std::exception& e) {
27337       {
27338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27339       };
27340     } catch (...) {
27341       {
27342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27343       };
27344     }
27345   }
27346
27347   //argout typemap for const std::string&
27348
27349 }
27350
27351
27352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
27353   unsigned int jresult ;
27354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27355   unsigned int result;
27356
27357   arg1 = (Dali::Actor *)jarg1;
27358   {
27359     try {
27360       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
27361     } catch (std::out_of_range& e) {
27362       {
27363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27364       };
27365     } catch (std::exception& e) {
27366       {
27367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27368       };
27369     } catch (...) {
27370       {
27371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27372       };
27373     }
27374   }
27375   jresult = result;
27376   return jresult;
27377 }
27378
27379
27380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
27381   unsigned int jresult ;
27382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27383   bool result;
27384
27385   arg1 = (Dali::Actor *)jarg1;
27386   {
27387     try {
27388       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
27389     } catch (std::out_of_range& e) {
27390       {
27391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27392       };
27393     } catch (std::exception& e) {
27394       {
27395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27396       };
27397     } catch (...) {
27398       {
27399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27400       };
27401     }
27402   }
27403   jresult = result;
27404   return jresult;
27405 }
27406
27407
27408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
27409   unsigned int jresult ;
27410   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27411   bool result;
27412
27413   arg1 = (Dali::Actor *)jarg1;
27414   {
27415     try {
27416       result = (bool)((Dali::Actor const *)arg1)->OnStage();
27417     } catch (std::out_of_range& e) {
27418       {
27419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27420       };
27421     } catch (std::exception& e) {
27422       {
27423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27424       };
27425     } catch (...) {
27426       {
27427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27428       };
27429     }
27430   }
27431   jresult = result;
27432   return jresult;
27433 }
27434
27435
27436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
27437   unsigned int jresult ;
27438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27439   bool result;
27440
27441   arg1 = (Dali::Actor *)jarg1;
27442   {
27443     try {
27444       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
27445     } catch (std::out_of_range& e) {
27446       {
27447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27448       };
27449     } catch (std::exception& e) {
27450       {
27451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27452       };
27453     } catch (...) {
27454       {
27455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27456       };
27457     }
27458   }
27459   jresult = result;
27460   return jresult;
27461 }
27462
27463
27464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
27465   void * jresult ;
27466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27467   Dali::Layer result;
27468
27469   arg1 = (Dali::Actor *)jarg1;
27470   {
27471     try {
27472       result = (arg1)->GetLayer();
27473     } catch (std::out_of_range& e) {
27474       {
27475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27476       };
27477     } catch (std::exception& e) {
27478       {
27479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27480       };
27481     } catch (...) {
27482       {
27483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27484       };
27485     }
27486   }
27487   jresult = new Dali::Layer((const Dali::Layer &)result);
27488   return jresult;
27489 }
27490
27491
27492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
27493   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27494   Dali::Actor arg2 ;
27495   Dali::Actor *argp2 ;
27496
27497   arg1 = (Dali::Actor *)jarg1;
27498   argp2 = (Dali::Actor *)jarg2;
27499   if (!argp2) {
27500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27501     return ;
27502   }
27503   arg2 = *argp2;
27504   {
27505     try {
27506       (arg1)->Add(arg2);
27507     } catch (std::out_of_range& e) {
27508       {
27509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27510       };
27511     } catch (std::exception& e) {
27512       {
27513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27514       };
27515     } catch (...) {
27516       {
27517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27518       };
27519     }
27520   }
27521 }
27522
27523
27524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
27525   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27526   Dali::Actor arg2 ;
27527   Dali::Actor *argp2 ;
27528
27529   arg1 = (Dali::Actor *)jarg1;
27530   argp2 = (Dali::Actor *)jarg2;
27531   if (!argp2) {
27532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27533     return ;
27534   }
27535   arg2 = *argp2;
27536   {
27537     try {
27538       (arg1)->Remove(arg2);
27539     } catch (std::out_of_range& e) {
27540       {
27541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27542       };
27543     } catch (std::exception& e) {
27544       {
27545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27546       };
27547     } catch (...) {
27548       {
27549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27550       };
27551     }
27552   }
27553 }
27554
27555
27556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
27557   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27558
27559   arg1 = (Dali::Actor *)jarg1;
27560   {
27561     try {
27562       (arg1)->Unparent();
27563     } catch (std::out_of_range& e) {
27564       {
27565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27566       };
27567     } catch (std::exception& e) {
27568       {
27569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27570       };
27571     } catch (...) {
27572       {
27573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27574       };
27575     }
27576   }
27577 }
27578
27579
27580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
27581   unsigned int jresult ;
27582   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27583   unsigned int result;
27584
27585   arg1 = (Dali::Actor *)jarg1;
27586   {
27587     try {
27588       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
27589     } catch (std::out_of_range& e) {
27590       {
27591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27592       };
27593     } catch (std::exception& e) {
27594       {
27595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27596       };
27597     } catch (...) {
27598       {
27599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27600       };
27601     }
27602   }
27603   jresult = result;
27604   return jresult;
27605 }
27606
27607
27608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
27609   void * jresult ;
27610   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27611   unsigned int arg2 ;
27612   Dali::Actor result;
27613
27614   arg1 = (Dali::Actor *)jarg1;
27615   arg2 = (unsigned int)jarg2;
27616   {
27617     try {
27618       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
27619     } catch (std::out_of_range& e) {
27620       {
27621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27622       };
27623     } catch (std::exception& e) {
27624       {
27625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27626       };
27627     } catch (...) {
27628       {
27629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27630       };
27631     }
27632   }
27633   jresult = new Dali::Actor((const Dali::Actor &)result);
27634   return jresult;
27635 }
27636
27637
27638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
27639   void * jresult ;
27640   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27641   std::string *arg2 = 0 ;
27642   Dali::Actor result;
27643
27644   arg1 = (Dali::Actor *)jarg1;
27645   if (!jarg2) {
27646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27647     return 0;
27648   }
27649   std::string arg2_str(jarg2);
27650   arg2 = &arg2_str;
27651   {
27652     try {
27653       result = (arg1)->FindChildByName((std::string const &)*arg2);
27654     } catch (std::out_of_range& e) {
27655       {
27656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27657       };
27658     } catch (std::exception& e) {
27659       {
27660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27661       };
27662     } catch (...) {
27663       {
27664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27665       };
27666     }
27667   }
27668   jresult = new Dali::Actor((const Dali::Actor &)result);
27669
27670   //argout typemap for const std::string&
27671
27672   return jresult;
27673 }
27674
27675
27676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
27677   void * jresult ;
27678   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27679   unsigned int arg2 ;
27680   Dali::Actor result;
27681
27682   arg1 = (Dali::Actor *)jarg1;
27683   arg2 = (unsigned int)jarg2;
27684   {
27685     try {
27686       result = (arg1)->FindChildById(arg2);
27687     } catch (std::out_of_range& e) {
27688       {
27689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27690       };
27691     } catch (std::exception& e) {
27692       {
27693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27694       };
27695     } catch (...) {
27696       {
27697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27698       };
27699     }
27700   }
27701   jresult = new Dali::Actor((const Dali::Actor &)result);
27702   return jresult;
27703 }
27704
27705
27706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
27707   void * jresult ;
27708   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27709   Dali::Actor result;
27710
27711   arg1 = (Dali::Actor *)jarg1;
27712   {
27713     try {
27714       result = ((Dali::Actor const *)arg1)->GetParent();
27715     } catch (std::out_of_range& e) {
27716       {
27717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27718       };
27719     } catch (std::exception& e) {
27720       {
27721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27722       };
27723     } catch (...) {
27724       {
27725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27726       };
27727     }
27728   }
27729   jresult = new Dali::Actor((const Dali::Actor &)result);
27730   return jresult;
27731 }
27732
27733
27734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
27735   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27736   Dali::Vector3 *arg2 = 0 ;
27737
27738   arg1 = (Dali::Actor *)jarg1;
27739   arg2 = (Dali::Vector3 *)jarg2;
27740   if (!arg2) {
27741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27742     return ;
27743   }
27744   {
27745     try {
27746       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
27747     } catch (std::out_of_range& e) {
27748       {
27749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27750       };
27751     } catch (std::exception& e) {
27752       {
27753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27754       };
27755     } catch (...) {
27756       {
27757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27758       };
27759     }
27760   }
27761 }
27762
27763
27764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
27765   void * jresult ;
27766   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27767   Dali::Vector3 result;
27768
27769   arg1 = (Dali::Actor *)jarg1;
27770   {
27771     try {
27772       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
27773     } catch (std::out_of_range& e) {
27774       {
27775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27776       };
27777     } catch (std::exception& e) {
27778       {
27779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27780       };
27781     } catch (...) {
27782       {
27783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27784       };
27785     }
27786   }
27787   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
27788   return jresult;
27789 }
27790
27791
27792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
27793   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27794   Dali::Vector3 *arg2 = 0 ;
27795
27796   arg1 = (Dali::Actor *)jarg1;
27797   arg2 = (Dali::Vector3 *)jarg2;
27798   if (!arg2) {
27799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27800     return ;
27801   }
27802   {
27803     try {
27804       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
27805     } catch (std::out_of_range& e) {
27806       {
27807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27808       };
27809     } catch (std::exception& e) {
27810       {
27811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27812       };
27813     } catch (...) {
27814       {
27815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27816       };
27817     }
27818   }
27819 }
27820
27821
27822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
27823   void * jresult ;
27824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27825   Dali::Vector3 result;
27826
27827   arg1 = (Dali::Actor *)jarg1;
27828   {
27829     try {
27830       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
27831     } catch (std::out_of_range& e) {
27832       {
27833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27834       };
27835     } catch (std::exception& e) {
27836       {
27837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27838       };
27839     } catch (...) {
27840       {
27841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27842       };
27843     }
27844   }
27845   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
27846   return jresult;
27847 }
27848
27849
27850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
27851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27852   float arg2 ;
27853   float arg3 ;
27854
27855   arg1 = (Dali::Actor *)jarg1;
27856   arg2 = (float)jarg2;
27857   arg3 = (float)jarg3;
27858   {
27859     try {
27860       (arg1)->SetSize(arg2,arg3);
27861     } catch (std::out_of_range& e) {
27862       {
27863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27864       };
27865     } catch (std::exception& e) {
27866       {
27867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27868       };
27869     } catch (...) {
27870       {
27871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27872       };
27873     }
27874   }
27875 }
27876
27877
27878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
27879   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27880   float arg2 ;
27881   float arg3 ;
27882   float arg4 ;
27883
27884   arg1 = (Dali::Actor *)jarg1;
27885   arg2 = (float)jarg2;
27886   arg3 = (float)jarg3;
27887   arg4 = (float)jarg4;
27888   {
27889     try {
27890       (arg1)->SetSize(arg2,arg3,arg4);
27891     } catch (std::out_of_range& e) {
27892       {
27893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27894       };
27895     } catch (std::exception& e) {
27896       {
27897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27898       };
27899     } catch (...) {
27900       {
27901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27902       };
27903     }
27904   }
27905 }
27906
27907
27908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
27909   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27910   Dali::Vector2 *arg2 = 0 ;
27911
27912   arg1 = (Dali::Actor *)jarg1;
27913   arg2 = (Dali::Vector2 *)jarg2;
27914   if (!arg2) {
27915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27916     return ;
27917   }
27918   {
27919     try {
27920       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
27921     } catch (std::out_of_range& e) {
27922       {
27923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27924       };
27925     } catch (std::exception& e) {
27926       {
27927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27928       };
27929     } catch (...) {
27930       {
27931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27932       };
27933     }
27934   }
27935 }
27936
27937
27938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
27939   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27940   Dali::Vector3 *arg2 = 0 ;
27941
27942   arg1 = (Dali::Actor *)jarg1;
27943   arg2 = (Dali::Vector3 *)jarg2;
27944   if (!arg2) {
27945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27946     return ;
27947   }
27948   {
27949     try {
27950       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
27951     } catch (std::out_of_range& e) {
27952       {
27953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27954       };
27955     } catch (std::exception& e) {
27956       {
27957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27958       };
27959     } catch (...) {
27960       {
27961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27962       };
27963     }
27964   }
27965 }
27966
27967
27968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
27969   void * jresult ;
27970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27971   Dali::Vector3 result;
27972
27973   arg1 = (Dali::Actor *)jarg1;
27974   {
27975     try {
27976       result = ((Dali::Actor const *)arg1)->GetTargetSize();
27977     } catch (std::out_of_range& e) {
27978       {
27979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27980       };
27981     } catch (std::exception& e) {
27982       {
27983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27984       };
27985     } catch (...) {
27986       {
27987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27988       };
27989     }
27990   }
27991   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
27992   return jresult;
27993 }
27994
27995
27996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
27997   void * jresult ;
27998   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
27999   Dali::Vector3 result;
28000
28001   arg1 = (Dali::Actor *)jarg1;
28002   {
28003     try {
28004       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
28005     } catch (std::out_of_range& e) {
28006       {
28007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28008       };
28009     } catch (std::exception& e) {
28010       {
28011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28012       };
28013     } catch (...) {
28014       {
28015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28016       };
28017     }
28018   }
28019   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28020   return jresult;
28021 }
28022
28023
28024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
28025   void * jresult ;
28026   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28027   Dali::Vector3 result;
28028
28029   arg1 = (Dali::Actor *)jarg1;
28030   {
28031     try {
28032       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
28033     } catch (std::out_of_range& e) {
28034       {
28035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28036       };
28037     } catch (std::exception& e) {
28038       {
28039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28040       };
28041     } catch (...) {
28042       {
28043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28044       };
28045     }
28046   }
28047   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28048   return jresult;
28049 }
28050
28051
28052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
28053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28054   float arg2 ;
28055   float arg3 ;
28056
28057   arg1 = (Dali::Actor *)jarg1;
28058   arg2 = (float)jarg2;
28059   arg3 = (float)jarg3;
28060   {
28061     try {
28062       (arg1)->SetPosition(arg2,arg3);
28063     } catch (std::out_of_range& e) {
28064       {
28065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28066       };
28067     } catch (std::exception& e) {
28068       {
28069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28070       };
28071     } catch (...) {
28072       {
28073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28074       };
28075     }
28076   }
28077 }
28078
28079
28080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
28081   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28082   float arg2 ;
28083   float arg3 ;
28084   float arg4 ;
28085
28086   arg1 = (Dali::Actor *)jarg1;
28087   arg2 = (float)jarg2;
28088   arg3 = (float)jarg3;
28089   arg4 = (float)jarg4;
28090   {
28091     try {
28092       (arg1)->SetPosition(arg2,arg3,arg4);
28093     } catch (std::out_of_range& e) {
28094       {
28095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28096       };
28097     } catch (std::exception& e) {
28098       {
28099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28100       };
28101     } catch (...) {
28102       {
28103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28104       };
28105     }
28106   }
28107 }
28108
28109
28110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
28111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28112   Dali::Vector3 *arg2 = 0 ;
28113
28114   arg1 = (Dali::Actor *)jarg1;
28115   arg2 = (Dali::Vector3 *)jarg2;
28116   if (!arg2) {
28117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28118     return ;
28119   }
28120   {
28121     try {
28122       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
28123     } catch (std::out_of_range& e) {
28124       {
28125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28126       };
28127     } catch (std::exception& e) {
28128       {
28129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28130       };
28131     } catch (...) {
28132       {
28133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28134       };
28135     }
28136   }
28137 }
28138
28139
28140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
28141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28142   float arg2 ;
28143
28144   arg1 = (Dali::Actor *)jarg1;
28145   arg2 = (float)jarg2;
28146   {
28147     try {
28148       (arg1)->SetX(arg2);
28149     } catch (std::out_of_range& e) {
28150       {
28151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28152       };
28153     } catch (std::exception& e) {
28154       {
28155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28156       };
28157     } catch (...) {
28158       {
28159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28160       };
28161     }
28162   }
28163 }
28164
28165
28166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
28167   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28168   float arg2 ;
28169
28170   arg1 = (Dali::Actor *)jarg1;
28171   arg2 = (float)jarg2;
28172   {
28173     try {
28174       (arg1)->SetY(arg2);
28175     } catch (std::out_of_range& e) {
28176       {
28177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28178       };
28179     } catch (std::exception& e) {
28180       {
28181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28182       };
28183     } catch (...) {
28184       {
28185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28186       };
28187     }
28188   }
28189 }
28190
28191
28192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
28193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28194   float arg2 ;
28195
28196   arg1 = (Dali::Actor *)jarg1;
28197   arg2 = (float)jarg2;
28198   {
28199     try {
28200       (arg1)->SetZ(arg2);
28201     } catch (std::out_of_range& e) {
28202       {
28203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28204       };
28205     } catch (std::exception& e) {
28206       {
28207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28208       };
28209     } catch (...) {
28210       {
28211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28212       };
28213     }
28214   }
28215 }
28216
28217
28218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
28219   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28220   Dali::Vector3 *arg2 = 0 ;
28221
28222   arg1 = (Dali::Actor *)jarg1;
28223   arg2 = (Dali::Vector3 *)jarg2;
28224   if (!arg2) {
28225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28226     return ;
28227   }
28228   {
28229     try {
28230       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
28231     } catch (std::out_of_range& e) {
28232       {
28233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28234       };
28235     } catch (std::exception& e) {
28236       {
28237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28238       };
28239     } catch (...) {
28240       {
28241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28242       };
28243     }
28244   }
28245 }
28246
28247
28248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
28249   void * jresult ;
28250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28251   Dali::Vector3 result;
28252
28253   arg1 = (Dali::Actor *)jarg1;
28254   {
28255     try {
28256       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
28257     } catch (std::out_of_range& e) {
28258       {
28259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28260       };
28261     } catch (std::exception& e) {
28262       {
28263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28264       };
28265     } catch (...) {
28266       {
28267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28268       };
28269     }
28270   }
28271   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28272   return jresult;
28273 }
28274
28275
28276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
28277   void * jresult ;
28278   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28279   Dali::Vector3 result;
28280
28281   arg1 = (Dali::Actor *)jarg1;
28282   {
28283     try {
28284       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
28285     } catch (std::out_of_range& e) {
28286       {
28287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28288       };
28289     } catch (std::exception& e) {
28290       {
28291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28292       };
28293     } catch (...) {
28294       {
28295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28296       };
28297     }
28298   }
28299   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28300   return jresult;
28301 }
28302
28303
28304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
28305   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28306   bool arg2 ;
28307
28308   arg1 = (Dali::Actor *)jarg1;
28309   arg2 = jarg2 ? true : false;
28310   {
28311     try {
28312       (arg1)->SetInheritPosition(arg2);
28313     } catch (std::out_of_range& e) {
28314       {
28315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28316       };
28317     } catch (std::exception& e) {
28318       {
28319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28320       };
28321     } catch (...) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28324       };
28325     }
28326   }
28327 }
28328
28329
28330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
28331   int jresult ;
28332   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28333   Dali::PositionInheritanceMode result;
28334
28335   arg1 = (Dali::Actor *)jarg1;
28336   {
28337     try {
28338       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
28339     } catch (std::out_of_range& e) {
28340       {
28341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28342       };
28343     } catch (std::exception& e) {
28344       {
28345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28346       };
28347     } catch (...) {
28348       {
28349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28350       };
28351     }
28352   }
28353   jresult = (int)result;
28354   return jresult;
28355 }
28356
28357
28358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
28359   unsigned int jresult ;
28360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28361   bool result;
28362
28363   arg1 = (Dali::Actor *)jarg1;
28364   {
28365     try {
28366       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
28367     } catch (std::out_of_range& e) {
28368       {
28369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28370       };
28371     } catch (std::exception& e) {
28372       {
28373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28374       };
28375     } catch (...) {
28376       {
28377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28378       };
28379     }
28380   }
28381   jresult = result;
28382   return jresult;
28383 }
28384
28385
28386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
28387   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28388   Dali::Degree *arg2 = 0 ;
28389   Dali::Vector3 *arg3 = 0 ;
28390
28391   arg1 = (Dali::Actor *)jarg1;
28392   arg2 = (Dali::Degree *)jarg2;
28393   if (!arg2) {
28394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
28395     return ;
28396   }
28397   arg3 = (Dali::Vector3 *)jarg3;
28398   if (!arg3) {
28399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28400     return ;
28401   }
28402   {
28403     try {
28404       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
28405     } catch (std::out_of_range& e) {
28406       {
28407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28408       };
28409     } catch (std::exception& e) {
28410       {
28411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28412       };
28413     } catch (...) {
28414       {
28415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28416       };
28417     }
28418   }
28419 }
28420
28421
28422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
28423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28424   Dali::Radian *arg2 = 0 ;
28425   Dali::Vector3 *arg3 = 0 ;
28426
28427   arg1 = (Dali::Actor *)jarg1;
28428   arg2 = (Dali::Radian *)jarg2;
28429   if (!arg2) {
28430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
28431     return ;
28432   }
28433   arg3 = (Dali::Vector3 *)jarg3;
28434   if (!arg3) {
28435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28436     return ;
28437   }
28438   {
28439     try {
28440       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
28441     } catch (std::out_of_range& e) {
28442       {
28443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28444       };
28445     } catch (std::exception& e) {
28446       {
28447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28448       };
28449     } catch (...) {
28450       {
28451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28452       };
28453     }
28454   }
28455 }
28456
28457
28458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
28459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28460   Dali::Quaternion *arg2 = 0 ;
28461
28462   arg1 = (Dali::Actor *)jarg1;
28463   arg2 = (Dali::Quaternion *)jarg2;
28464   if (!arg2) {
28465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
28466     return ;
28467   }
28468   {
28469     try {
28470       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
28471     } catch (std::out_of_range& e) {
28472       {
28473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28474       };
28475     } catch (std::exception& e) {
28476       {
28477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28478       };
28479     } catch (...) {
28480       {
28481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28482       };
28483     }
28484   }
28485 }
28486
28487
28488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
28489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28490   Dali::Degree *arg2 = 0 ;
28491   Dali::Vector3 *arg3 = 0 ;
28492
28493   arg1 = (Dali::Actor *)jarg1;
28494   arg2 = (Dali::Degree *)jarg2;
28495   if (!arg2) {
28496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
28497     return ;
28498   }
28499   arg3 = (Dali::Vector3 *)jarg3;
28500   if (!arg3) {
28501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28502     return ;
28503   }
28504   {
28505     try {
28506       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
28507     } catch (std::out_of_range& e) {
28508       {
28509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28510       };
28511     } catch (std::exception& e) {
28512       {
28513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28514       };
28515     } catch (...) {
28516       {
28517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28518       };
28519     }
28520   }
28521 }
28522
28523
28524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
28525   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28526   Dali::Radian *arg2 = 0 ;
28527   Dali::Vector3 *arg3 = 0 ;
28528
28529   arg1 = (Dali::Actor *)jarg1;
28530   arg2 = (Dali::Radian *)jarg2;
28531   if (!arg2) {
28532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
28533     return ;
28534   }
28535   arg3 = (Dali::Vector3 *)jarg3;
28536   if (!arg3) {
28537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28538     return ;
28539   }
28540   {
28541     try {
28542       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
28543     } catch (std::out_of_range& e) {
28544       {
28545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28546       };
28547     } catch (std::exception& e) {
28548       {
28549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28550       };
28551     } catch (...) {
28552       {
28553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28554       };
28555     }
28556   }
28557 }
28558
28559
28560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
28561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28562   Dali::Quaternion *arg2 = 0 ;
28563
28564   arg1 = (Dali::Actor *)jarg1;
28565   arg2 = (Dali::Quaternion *)jarg2;
28566   if (!arg2) {
28567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
28568     return ;
28569   }
28570   {
28571     try {
28572       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
28573     } catch (std::out_of_range& e) {
28574       {
28575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28576       };
28577     } catch (std::exception& e) {
28578       {
28579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28580       };
28581     } catch (...) {
28582       {
28583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28584       };
28585     }
28586   }
28587 }
28588
28589
28590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
28591   void * jresult ;
28592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28593   Dali::Quaternion result;
28594
28595   arg1 = (Dali::Actor *)jarg1;
28596   {
28597     try {
28598       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
28599     } catch (std::out_of_range& e) {
28600       {
28601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28602       };
28603     } catch (std::exception& e) {
28604       {
28605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28606       };
28607     } catch (...) {
28608       {
28609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28610       };
28611     }
28612   }
28613   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
28614   return jresult;
28615 }
28616
28617
28618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
28619   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28620   bool arg2 ;
28621
28622   arg1 = (Dali::Actor *)jarg1;
28623   arg2 = jarg2 ? true : false;
28624   {
28625     try {
28626       (arg1)->SetInheritOrientation(arg2);
28627     } catch (std::out_of_range& e) {
28628       {
28629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28630       };
28631     } catch (std::exception& e) {
28632       {
28633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28634       };
28635     } catch (...) {
28636       {
28637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28638       };
28639     }
28640   }
28641 }
28642
28643
28644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
28645   unsigned int jresult ;
28646   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28647   bool result;
28648
28649   arg1 = (Dali::Actor *)jarg1;
28650   {
28651     try {
28652       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
28653     } catch (std::out_of_range& e) {
28654       {
28655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28656       };
28657     } catch (std::exception& e) {
28658       {
28659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28660       };
28661     } catch (...) {
28662       {
28663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28664       };
28665     }
28666   }
28667   jresult = result;
28668   return jresult;
28669 }
28670
28671
28672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
28673   void * jresult ;
28674   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28675   Dali::Quaternion result;
28676
28677   arg1 = (Dali::Actor *)jarg1;
28678   {
28679     try {
28680       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
28681     } catch (std::out_of_range& e) {
28682       {
28683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28684       };
28685     } catch (std::exception& e) {
28686       {
28687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28688       };
28689     } catch (...) {
28690       {
28691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28692       };
28693     }
28694   }
28695   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
28696   return jresult;
28697 }
28698
28699
28700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
28701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28702   float arg2 ;
28703
28704   arg1 = (Dali::Actor *)jarg1;
28705   arg2 = (float)jarg2;
28706   {
28707     try {
28708       (arg1)->SetScale(arg2);
28709     } catch (std::out_of_range& e) {
28710       {
28711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28712       };
28713     } catch (std::exception& e) {
28714       {
28715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28716       };
28717     } catch (...) {
28718       {
28719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28720       };
28721     }
28722   }
28723 }
28724
28725
28726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
28727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28728   float arg2 ;
28729   float arg3 ;
28730   float arg4 ;
28731
28732   arg1 = (Dali::Actor *)jarg1;
28733   arg2 = (float)jarg2;
28734   arg3 = (float)jarg3;
28735   arg4 = (float)jarg4;
28736   {
28737     try {
28738       (arg1)->SetScale(arg2,arg3,arg4);
28739     } catch (std::out_of_range& e) {
28740       {
28741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28742       };
28743     } catch (std::exception& e) {
28744       {
28745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28746       };
28747     } catch (...) {
28748       {
28749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28750       };
28751     }
28752   }
28753 }
28754
28755
28756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
28757   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28758   Dali::Vector3 *arg2 = 0 ;
28759
28760   arg1 = (Dali::Actor *)jarg1;
28761   arg2 = (Dali::Vector3 *)jarg2;
28762   if (!arg2) {
28763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28764     return ;
28765   }
28766   {
28767     try {
28768       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
28769     } catch (std::out_of_range& e) {
28770       {
28771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28772       };
28773     } catch (std::exception& e) {
28774       {
28775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28776       };
28777     } catch (...) {
28778       {
28779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28780       };
28781     }
28782   }
28783 }
28784
28785
28786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
28787   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28788   Dali::Vector3 *arg2 = 0 ;
28789
28790   arg1 = (Dali::Actor *)jarg1;
28791   arg2 = (Dali::Vector3 *)jarg2;
28792   if (!arg2) {
28793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28794     return ;
28795   }
28796   {
28797     try {
28798       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
28799     } catch (std::out_of_range& e) {
28800       {
28801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28802       };
28803     } catch (std::exception& e) {
28804       {
28805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28806       };
28807     } catch (...) {
28808       {
28809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28810       };
28811     }
28812   }
28813 }
28814
28815
28816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
28817   void * jresult ;
28818   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28819   Dali::Vector3 result;
28820
28821   arg1 = (Dali::Actor *)jarg1;
28822   {
28823     try {
28824       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
28825     } catch (std::out_of_range& e) {
28826       {
28827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28828       };
28829     } catch (std::exception& e) {
28830       {
28831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28832       };
28833     } catch (...) {
28834       {
28835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28836       };
28837     }
28838   }
28839   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28840   return jresult;
28841 }
28842
28843
28844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
28845   void * jresult ;
28846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28847   Dali::Vector3 result;
28848
28849   arg1 = (Dali::Actor *)jarg1;
28850   {
28851     try {
28852       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
28853     } catch (std::out_of_range& e) {
28854       {
28855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28856       };
28857     } catch (std::exception& e) {
28858       {
28859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28860       };
28861     } catch (...) {
28862       {
28863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28864       };
28865     }
28866   }
28867   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28868   return jresult;
28869 }
28870
28871
28872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
28873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28874   bool arg2 ;
28875
28876   arg1 = (Dali::Actor *)jarg1;
28877   arg2 = jarg2 ? true : false;
28878   {
28879     try {
28880       (arg1)->SetInheritScale(arg2);
28881     } catch (std::out_of_range& e) {
28882       {
28883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28884       };
28885     } catch (std::exception& e) {
28886       {
28887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28888       };
28889     } catch (...) {
28890       {
28891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28892       };
28893     }
28894   }
28895 }
28896
28897
28898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
28899   unsigned int jresult ;
28900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28901   bool result;
28902
28903   arg1 = (Dali::Actor *)jarg1;
28904   {
28905     try {
28906       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
28907     } catch (std::out_of_range& e) {
28908       {
28909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28910       };
28911     } catch (std::exception& e) {
28912       {
28913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28914       };
28915     } catch (...) {
28916       {
28917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28918       };
28919     }
28920   }
28921   jresult = result;
28922   return jresult;
28923 }
28924
28925
28926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
28927   void * jresult ;
28928   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28929   Dali::Matrix result;
28930
28931   arg1 = (Dali::Actor *)jarg1;
28932   {
28933     try {
28934       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
28935     } catch (std::out_of_range& e) {
28936       {
28937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28938       };
28939     } catch (std::exception& e) {
28940       {
28941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28942       };
28943     } catch (...) {
28944       {
28945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28946       };
28947     }
28948   }
28949   jresult = new Dali::Matrix((const Dali::Matrix &)result);
28950   return jresult;
28951 }
28952
28953
28954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
28955   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28956   bool arg2 ;
28957
28958   arg1 = (Dali::Actor *)jarg1;
28959   arg2 = jarg2 ? true : false;
28960   {
28961     try {
28962       (arg1)->SetVisible(arg2);
28963     } catch (std::out_of_range& e) {
28964       {
28965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28966       };
28967     } catch (std::exception& e) {
28968       {
28969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28970       };
28971     } catch (...) {
28972       {
28973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28974       };
28975     }
28976   }
28977 }
28978
28979
28980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
28981   unsigned int jresult ;
28982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28983   bool result;
28984
28985   arg1 = (Dali::Actor *)jarg1;
28986   {
28987     try {
28988       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
28989     } catch (std::out_of_range& e) {
28990       {
28991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28992       };
28993     } catch (std::exception& e) {
28994       {
28995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28996       };
28997     } catch (...) {
28998       {
28999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29000       };
29001     }
29002   }
29003   jresult = result;
29004   return jresult;
29005 }
29006
29007
29008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
29009   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29010   float arg2 ;
29011
29012   arg1 = (Dali::Actor *)jarg1;
29013   arg2 = (float)jarg2;
29014   {
29015     try {
29016       (arg1)->SetOpacity(arg2);
29017     } catch (std::out_of_range& e) {
29018       {
29019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29020       };
29021     } catch (std::exception& e) {
29022       {
29023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29024       };
29025     } catch (...) {
29026       {
29027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29028       };
29029     }
29030   }
29031 }
29032
29033
29034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
29035   float jresult ;
29036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29037   float result;
29038
29039   arg1 = (Dali::Actor *)jarg1;
29040   {
29041     try {
29042       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
29043     } catch (std::out_of_range& e) {
29044       {
29045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29046       };
29047     } catch (std::exception& e) {
29048       {
29049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29050       };
29051     } catch (...) {
29052       {
29053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29054       };
29055     }
29056   }
29057   jresult = result;
29058   return jresult;
29059 }
29060
29061
29062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
29063   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29064   Dali::Vector4 *arg2 = 0 ;
29065
29066   arg1 = (Dali::Actor *)jarg1;
29067   arg2 = (Dali::Vector4 *)jarg2;
29068   if (!arg2) {
29069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29070     return ;
29071   }
29072   {
29073     try {
29074       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
29075     } catch (std::out_of_range& e) {
29076       {
29077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29078       };
29079     } catch (std::exception& e) {
29080       {
29081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29082       };
29083     } catch (...) {
29084       {
29085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29086       };
29087     }
29088   }
29089 }
29090
29091
29092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
29093   void * jresult ;
29094   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29095   Dali::Vector4 result;
29096
29097   arg1 = (Dali::Actor *)jarg1;
29098   {
29099     try {
29100       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
29101     } catch (std::out_of_range& e) {
29102       {
29103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29104       };
29105     } catch (std::exception& e) {
29106       {
29107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29108       };
29109     } catch (...) {
29110       {
29111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29112       };
29113     }
29114   }
29115   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29116   return jresult;
29117 }
29118
29119
29120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
29121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29122   Dali::ColorMode arg2 ;
29123
29124   arg1 = (Dali::Actor *)jarg1;
29125   arg2 = (Dali::ColorMode)jarg2;
29126   {
29127     try {
29128       (arg1)->SetColorMode(arg2);
29129     } catch (std::out_of_range& e) {
29130       {
29131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29132       };
29133     } catch (std::exception& e) {
29134       {
29135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29136       };
29137     } catch (...) {
29138       {
29139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29140       };
29141     }
29142   }
29143 }
29144
29145
29146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
29147   int jresult ;
29148   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29149   Dali::ColorMode result;
29150
29151   arg1 = (Dali::Actor *)jarg1;
29152   {
29153     try {
29154       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
29155     } catch (std::out_of_range& e) {
29156       {
29157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29158       };
29159     } catch (std::exception& e) {
29160       {
29161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29162       };
29163     } catch (...) {
29164       {
29165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29166       };
29167     }
29168   }
29169   jresult = (int)result;
29170   return jresult;
29171 }
29172
29173
29174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
29175   void * jresult ;
29176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29177   Dali::Vector4 result;
29178
29179   arg1 = (Dali::Actor *)jarg1;
29180   {
29181     try {
29182       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
29183     } catch (std::out_of_range& e) {
29184       {
29185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29186       };
29187     } catch (std::exception& e) {
29188       {
29189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29190       };
29191     } catch (...) {
29192       {
29193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29194       };
29195     }
29196   }
29197   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29198   return jresult;
29199 }
29200
29201
29202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
29203   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29204   Dali::DrawMode::Type arg2 ;
29205
29206   arg1 = (Dali::Actor *)jarg1;
29207   arg2 = (Dali::DrawMode::Type)jarg2;
29208   {
29209     try {
29210       (arg1)->SetDrawMode(arg2);
29211     } catch (std::out_of_range& e) {
29212       {
29213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29214       };
29215     } catch (std::exception& e) {
29216       {
29217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29218       };
29219     } catch (...) {
29220       {
29221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29222       };
29223     }
29224   }
29225 }
29226
29227
29228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
29229   int jresult ;
29230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29231   Dali::DrawMode::Type result;
29232
29233   arg1 = (Dali::Actor *)jarg1;
29234   {
29235     try {
29236       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
29237     } catch (std::out_of_range& e) {
29238       {
29239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29240       };
29241     } catch (std::exception& e) {
29242       {
29243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29244       };
29245     } catch (...) {
29246       {
29247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29248       };
29249     }
29250   }
29251   jresult = (int)result;
29252   return jresult;
29253 }
29254
29255
29256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
29257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29258   bool arg2 ;
29259
29260   arg1 = (Dali::Actor *)jarg1;
29261   arg2 = jarg2 ? true : false;
29262   {
29263     try {
29264       (arg1)->SetSensitive(arg2);
29265     } catch (std::out_of_range& e) {
29266       {
29267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29268       };
29269     } catch (std::exception& e) {
29270       {
29271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29272       };
29273     } catch (...) {
29274       {
29275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29276       };
29277     }
29278   }
29279 }
29280
29281
29282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
29283   unsigned int jresult ;
29284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29285   bool result;
29286
29287   arg1 = (Dali::Actor *)jarg1;
29288   {
29289     try {
29290       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
29291     } catch (std::out_of_range& e) {
29292       {
29293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29294       };
29295     } catch (std::exception& e) {
29296       {
29297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29298       };
29299     } catch (...) {
29300       {
29301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29302       };
29303     }
29304   }
29305   jresult = result;
29306   return jresult;
29307 }
29308
29309
29310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
29311   unsigned int jresult ;
29312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29313   float *arg2 = 0 ;
29314   float *arg3 = 0 ;
29315   float arg4 ;
29316   float arg5 ;
29317   bool result;
29318
29319   arg1 = (Dali::Actor *)jarg1;
29320   arg2 = (float *)jarg2;
29321   arg3 = (float *)jarg3;
29322   arg4 = (float)jarg4;
29323   arg5 = (float)jarg5;
29324   {
29325     try {
29326       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
29327     } catch (std::out_of_range& e) {
29328       {
29329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29330       };
29331     } catch (std::exception& e) {
29332       {
29333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29334       };
29335     } catch (...) {
29336       {
29337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29338       };
29339     }
29340   }
29341   jresult = result;
29342   return jresult;
29343 }
29344
29345
29346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
29347   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29348   bool arg2 ;
29349
29350   arg1 = (Dali::Actor *)jarg1;
29351   arg2 = jarg2 ? true : false;
29352   {
29353     try {
29354       (arg1)->SetLeaveRequired(arg2);
29355     } catch (std::out_of_range& e) {
29356       {
29357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29358       };
29359     } catch (std::exception& e) {
29360       {
29361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29362       };
29363     } catch (...) {
29364       {
29365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29366       };
29367     }
29368   }
29369 }
29370
29371
29372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
29373   unsigned int jresult ;
29374   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29375   bool result;
29376
29377   arg1 = (Dali::Actor *)jarg1;
29378   {
29379     try {
29380       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
29381     } catch (std::out_of_range& e) {
29382       {
29383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29384       };
29385     } catch (std::exception& e) {
29386       {
29387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29388       };
29389     } catch (...) {
29390       {
29391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29392       };
29393     }
29394   }
29395   jresult = result;
29396   return jresult;
29397 }
29398
29399
29400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
29401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29402   bool arg2 ;
29403
29404   arg1 = (Dali::Actor *)jarg1;
29405   arg2 = jarg2 ? true : false;
29406   {
29407     try {
29408       (arg1)->SetKeyboardFocusable(arg2);
29409     } catch (std::out_of_range& e) {
29410       {
29411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29412       };
29413     } catch (std::exception& e) {
29414       {
29415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29416       };
29417     } catch (...) {
29418       {
29419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29420       };
29421     }
29422   }
29423 }
29424
29425
29426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
29427   unsigned int jresult ;
29428   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29429   bool result;
29430
29431   arg1 = (Dali::Actor *)jarg1;
29432   {
29433     try {
29434       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
29435     } catch (std::out_of_range& e) {
29436       {
29437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29438       };
29439     } catch (std::exception& e) {
29440       {
29441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29442       };
29443     } catch (...) {
29444       {
29445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29446       };
29447     }
29448   }
29449   jresult = result;
29450   return jresult;
29451 }
29452
29453
29454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
29455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29456   Dali::ResizePolicy::Type arg2 ;
29457   Dali::Dimension::Type arg3 ;
29458
29459   arg1 = (Dali::Actor *)jarg1;
29460   arg2 = (Dali::ResizePolicy::Type)jarg2;
29461   arg3 = (Dali::Dimension::Type)jarg3;
29462   {
29463     try {
29464       (arg1)->SetResizePolicy(arg2,arg3);
29465     } catch (std::out_of_range& e) {
29466       {
29467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29468       };
29469     } catch (std::exception& e) {
29470       {
29471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29472       };
29473     } catch (...) {
29474       {
29475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29476       };
29477     }
29478   }
29479 }
29480
29481
29482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
29483   int jresult ;
29484   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29485   Dali::Dimension::Type arg2 ;
29486   Dali::ResizePolicy::Type result;
29487
29488   arg1 = (Dali::Actor *)jarg1;
29489   arg2 = (Dali::Dimension::Type)jarg2;
29490   {
29491     try {
29492       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
29493     } catch (std::out_of_range& e) {
29494       {
29495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29496       };
29497     } catch (std::exception& e) {
29498       {
29499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29500       };
29501     } catch (...) {
29502       {
29503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29504       };
29505     }
29506   }
29507   jresult = (int)result;
29508   return jresult;
29509 }
29510
29511
29512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
29513   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29514   Dali::SizeScalePolicy::Type arg2 ;
29515
29516   arg1 = (Dali::Actor *)jarg1;
29517   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
29518   {
29519     try {
29520       (arg1)->SetSizeScalePolicy(arg2);
29521     } catch (std::out_of_range& e) {
29522       {
29523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29524       };
29525     } catch (std::exception& e) {
29526       {
29527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29528       };
29529     } catch (...) {
29530       {
29531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29532       };
29533     }
29534   }
29535 }
29536
29537
29538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
29539   int jresult ;
29540   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29541   Dali::SizeScalePolicy::Type result;
29542
29543   arg1 = (Dali::Actor *)jarg1;
29544   {
29545     try {
29546       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
29547     } catch (std::out_of_range& e) {
29548       {
29549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29550       };
29551     } catch (std::exception& e) {
29552       {
29553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29554       };
29555     } catch (...) {
29556       {
29557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29558       };
29559     }
29560   }
29561   jresult = (int)result;
29562   return jresult;
29563 }
29564
29565
29566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
29567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29568   Dali::Vector3 *arg2 = 0 ;
29569
29570   arg1 = (Dali::Actor *)jarg1;
29571   arg2 = (Dali::Vector3 *)jarg2;
29572   if (!arg2) {
29573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29574     return ;
29575   }
29576   {
29577     try {
29578       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
29579     } catch (std::out_of_range& e) {
29580       {
29581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29582       };
29583     } catch (std::exception& e) {
29584       {
29585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29586       };
29587     } catch (...) {
29588       {
29589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29590       };
29591     }
29592   }
29593 }
29594
29595
29596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
29597   void * jresult ;
29598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29599   Dali::Vector3 result;
29600
29601   arg1 = (Dali::Actor *)jarg1;
29602   {
29603     try {
29604       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
29605     } catch (std::out_of_range& e) {
29606       {
29607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29608       };
29609     } catch (std::exception& e) {
29610       {
29611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29612       };
29613     } catch (...) {
29614       {
29615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29616       };
29617     }
29618   }
29619   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29620   return jresult;
29621 }
29622
29623
29624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
29625   float jresult ;
29626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29627   float arg2 ;
29628   float result;
29629
29630   arg1 = (Dali::Actor *)jarg1;
29631   arg2 = (float)jarg2;
29632   {
29633     try {
29634       result = (float)(arg1)->GetHeightForWidth(arg2);
29635     } catch (std::out_of_range& e) {
29636       {
29637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29638       };
29639     } catch (std::exception& e) {
29640       {
29641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29642       };
29643     } catch (...) {
29644       {
29645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29646       };
29647     }
29648   }
29649   jresult = result;
29650   return jresult;
29651 }
29652
29653
29654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
29655   float jresult ;
29656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29657   float arg2 ;
29658   float result;
29659
29660   arg1 = (Dali::Actor *)jarg1;
29661   arg2 = (float)jarg2;
29662   {
29663     try {
29664       result = (float)(arg1)->GetWidthForHeight(arg2);
29665     } catch (std::out_of_range& e) {
29666       {
29667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29668       };
29669     } catch (std::exception& e) {
29670       {
29671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29672       };
29673     } catch (...) {
29674       {
29675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29676       };
29677     }
29678   }
29679   jresult = result;
29680   return jresult;
29681 }
29682
29683
29684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
29685   float jresult ;
29686   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29687   Dali::Dimension::Type arg2 ;
29688   float result;
29689
29690   arg1 = (Dali::Actor *)jarg1;
29691   arg2 = (Dali::Dimension::Type)jarg2;
29692   {
29693     try {
29694       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
29695     } catch (std::out_of_range& e) {
29696       {
29697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29698       };
29699     } catch (std::exception& e) {
29700       {
29701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29702       };
29703     } catch (...) {
29704       {
29705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29706       };
29707     }
29708   }
29709   jresult = result;
29710   return jresult;
29711 }
29712
29713
29714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
29715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29716   Dali::Padding *arg2 = 0 ;
29717
29718   arg1 = (Dali::Actor *)jarg1;
29719   arg2 = (Dali::Padding *)jarg2;
29720   if (!arg2) {
29721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
29722     return ;
29723   }
29724   {
29725     try {
29726       (arg1)->SetPadding((Dali::Padding const &)*arg2);
29727     } catch (std::out_of_range& e) {
29728       {
29729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29730       };
29731     } catch (std::exception& e) {
29732       {
29733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29734       };
29735     } catch (...) {
29736       {
29737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29738       };
29739     }
29740   }
29741 }
29742
29743
29744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
29745   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29746   Dali::Padding *arg2 = 0 ;
29747
29748   arg1 = (Dali::Actor *)jarg1;
29749   arg2 = (Dali::Padding *)jarg2;
29750   if (!arg2) {
29751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
29752     return ;
29753   }
29754   {
29755     try {
29756       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
29757     } catch (std::out_of_range& e) {
29758       {
29759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29760       };
29761     } catch (std::exception& e) {
29762       {
29763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29764       };
29765     } catch (...) {
29766       {
29767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29768       };
29769     }
29770   }
29771 }
29772
29773
29774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
29775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29776   Dali::Vector2 *arg2 = 0 ;
29777
29778   arg1 = (Dali::Actor *)jarg1;
29779   arg2 = (Dali::Vector2 *)jarg2;
29780   if (!arg2) {
29781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29782     return ;
29783   }
29784   {
29785     try {
29786       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
29787     } catch (std::out_of_range& e) {
29788       {
29789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29790       };
29791     } catch (std::exception& e) {
29792       {
29793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29794       };
29795     } catch (...) {
29796       {
29797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29798       };
29799     }
29800   }
29801 }
29802
29803
29804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
29805   void * jresult ;
29806   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29807   Dali::Vector2 result;
29808
29809   arg1 = (Dali::Actor *)jarg1;
29810   {
29811     try {
29812       result = (arg1)->GetMinimumSize();
29813     } catch (std::out_of_range& e) {
29814       {
29815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29816       };
29817     } catch (std::exception& e) {
29818       {
29819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29820       };
29821     } catch (...) {
29822       {
29823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29824       };
29825     }
29826   }
29827   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29828   return jresult;
29829 }
29830
29831
29832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
29833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29834   Dali::Vector2 *arg2 = 0 ;
29835
29836   arg1 = (Dali::Actor *)jarg1;
29837   arg2 = (Dali::Vector2 *)jarg2;
29838   if (!arg2) {
29839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29840     return ;
29841   }
29842   {
29843     try {
29844       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
29845     } catch (std::out_of_range& e) {
29846       {
29847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29848       };
29849     } catch (std::exception& e) {
29850       {
29851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29852       };
29853     } catch (...) {
29854       {
29855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29856       };
29857     }
29858   }
29859 }
29860
29861
29862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
29863   void * jresult ;
29864   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29865   Dali::Vector2 result;
29866
29867   arg1 = (Dali::Actor *)jarg1;
29868   {
29869     try {
29870       result = (arg1)->GetMaximumSize();
29871     } catch (std::out_of_range& e) {
29872       {
29873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29874       };
29875     } catch (std::exception& e) {
29876       {
29877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29878       };
29879     } catch (...) {
29880       {
29881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29882       };
29883     }
29884   }
29885   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29886   return jresult;
29887 }
29888
29889
29890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
29891   int jresult ;
29892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29893   int result;
29894
29895   arg1 = (Dali::Actor *)jarg1;
29896   {
29897     try {
29898       result = (int)(arg1)->GetHierarchyDepth();
29899     } catch (std::out_of_range& e) {
29900       {
29901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29902       };
29903     } catch (std::exception& e) {
29904       {
29905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29906       };
29907     } catch (...) {
29908       {
29909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29910       };
29911     }
29912   }
29913   jresult = result;
29914   return jresult;
29915 }
29916
29917
29918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
29919   unsigned int jresult ;
29920   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29921   Dali::Renderer *arg2 = 0 ;
29922   unsigned int result;
29923
29924   arg1 = (Dali::Actor *)jarg1;
29925   arg2 = (Dali::Renderer *)jarg2;
29926   if (!arg2) {
29927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
29928     return 0;
29929   }
29930   {
29931     try {
29932       result = (unsigned int)(arg1)->AddRenderer(*arg2);
29933     } catch (std::out_of_range& e) {
29934       {
29935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29936       };
29937     } catch (std::exception& e) {
29938       {
29939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29940       };
29941     } catch (...) {
29942       {
29943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29944       };
29945     }
29946   }
29947   jresult = result;
29948   return jresult;
29949 }
29950
29951
29952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
29953   unsigned int jresult ;
29954   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29955   unsigned int result;
29956
29957   arg1 = (Dali::Actor *)jarg1;
29958   {
29959     try {
29960       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
29961     } catch (std::out_of_range& e) {
29962       {
29963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29964       };
29965     } catch (std::exception& e) {
29966       {
29967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29968       };
29969     } catch (...) {
29970       {
29971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29972       };
29973     }
29974   }
29975   jresult = result;
29976   return jresult;
29977 }
29978
29979
29980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
29981   void * jresult ;
29982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29983   unsigned int arg2 ;
29984   Dali::Renderer result;
29985
29986   arg1 = (Dali::Actor *)jarg1;
29987   arg2 = (unsigned int)jarg2;
29988   {
29989     try {
29990       result = (arg1)->GetRendererAt(arg2);
29991     } catch (std::out_of_range& e) {
29992       {
29993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29994       };
29995     } catch (std::exception& e) {
29996       {
29997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29998       };
29999     } catch (...) {
30000       {
30001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30002       };
30003     }
30004   }
30005   jresult = new Dali::Renderer((const Dali::Renderer &)result);
30006   return jresult;
30007 }
30008
30009
30010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
30011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30012   Dali::Renderer *arg2 = 0 ;
30013
30014   arg1 = (Dali::Actor *)jarg1;
30015   arg2 = (Dali::Renderer *)jarg2;
30016   if (!arg2) {
30017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
30018     return ;
30019   }
30020   {
30021     try {
30022       (arg1)->RemoveRenderer(*arg2);
30023     } catch (std::out_of_range& e) {
30024       {
30025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30026       };
30027     } catch (std::exception& e) {
30028       {
30029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30030       };
30031     } catch (...) {
30032       {
30033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30034       };
30035     }
30036   }
30037 }
30038
30039
30040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
30041   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30042   unsigned int arg2 ;
30043
30044   arg1 = (Dali::Actor *)jarg1;
30045   arg2 = (unsigned int)jarg2;
30046   {
30047     try {
30048       (arg1)->RemoveRenderer(arg2);
30049     } catch (std::out_of_range& e) {
30050       {
30051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30052       };
30053     } catch (std::exception& e) {
30054       {
30055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30056       };
30057     } catch (...) {
30058       {
30059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30060       };
30061     }
30062   }
30063 }
30064
30065
30066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
30067   void * jresult ;
30068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30069   Dali::Actor::TouchSignalType *result = 0 ;
30070
30071   arg1 = (Dali::Actor *)jarg1;
30072   {
30073     try {
30074       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
30075     } catch (std::out_of_range& e) {
30076       {
30077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30078       };
30079     } catch (std::exception& e) {
30080       {
30081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30082       };
30083     } catch (...) {
30084       {
30085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30086       };
30087     }
30088   }
30089   jresult = (void *)result;
30090   return jresult;
30091 }
30092
30093
30094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
30095   void * jresult ;
30096   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30097   Dali::Actor::TouchDataSignalType *result = 0 ;
30098
30099   arg1 = (Dali::Actor *)jarg1;
30100   {
30101     try {
30102       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
30103     } catch (std::out_of_range& e) {
30104       {
30105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30106       };
30107     } catch (std::exception& e) {
30108       {
30109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30110       };
30111     } catch (...) {
30112       {
30113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30114       };
30115     }
30116   }
30117   jresult = (void *)result;
30118   return jresult;
30119 }
30120
30121
30122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
30123   void * jresult ;
30124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30125   Dali::Actor::HoverSignalType *result = 0 ;
30126
30127   arg1 = (Dali::Actor *)jarg1;
30128   {
30129     try {
30130       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
30131     } catch (std::out_of_range& e) {
30132       {
30133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30134       };
30135     } catch (std::exception& e) {
30136       {
30137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30138       };
30139     } catch (...) {
30140       {
30141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30142       };
30143     }
30144   }
30145   jresult = (void *)result;
30146   return jresult;
30147 }
30148
30149
30150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
30151   void * jresult ;
30152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30153   Dali::Actor::WheelEventSignalType *result = 0 ;
30154
30155   arg1 = (Dali::Actor *)jarg1;
30156   {
30157     try {
30158       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
30159     } catch (std::out_of_range& e) {
30160       {
30161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30162       };
30163     } catch (std::exception& e) {
30164       {
30165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30166       };
30167     } catch (...) {
30168       {
30169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30170       };
30171     }
30172   }
30173   jresult = (void *)result;
30174   return jresult;
30175 }
30176
30177
30178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
30179   void * jresult ;
30180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30181   Dali::Actor::OnStageSignalType *result = 0 ;
30182
30183   arg1 = (Dali::Actor *)jarg1;
30184   {
30185     try {
30186       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
30187     } catch (std::out_of_range& e) {
30188       {
30189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30190       };
30191     } catch (std::exception& e) {
30192       {
30193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30194       };
30195     } catch (...) {
30196       {
30197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30198       };
30199     }
30200   }
30201   jresult = (void *)result;
30202   return jresult;
30203 }
30204
30205
30206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
30207   void * jresult ;
30208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30209   Dali::Actor::OffStageSignalType *result = 0 ;
30210
30211   arg1 = (Dali::Actor *)jarg1;
30212   {
30213     try {
30214       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
30215     } catch (std::out_of_range& e) {
30216       {
30217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30218       };
30219     } catch (std::exception& e) {
30220       {
30221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30222       };
30223     } catch (...) {
30224       {
30225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30226       };
30227     }
30228   }
30229   jresult = (void *)result;
30230   return jresult;
30231 }
30232
30233
30234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
30235   void * jresult ;
30236   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30237   Dali::Actor::OnRelayoutSignalType *result = 0 ;
30238
30239   arg1 = (Dali::Actor *)jarg1;
30240   {
30241     try {
30242       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
30243     } catch (std::out_of_range& e) {
30244       {
30245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30246       };
30247     } catch (std::exception& e) {
30248       {
30249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30250       };
30251     } catch (...) {
30252       {
30253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30254       };
30255     }
30256   }
30257   jresult = (void *)result;
30258   return jresult;
30259 }
30260
30261
30262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
30263   Dali::Actor *arg1 = 0 ;
30264
30265   arg1 = (Dali::Actor *)jarg1;
30266   if (!arg1) {
30267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
30268     return ;
30269   }
30270   {
30271     try {
30272       Dali::UnparentAndReset(*arg1);
30273     } catch (std::out_of_range& e) {
30274       {
30275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30276       };
30277     } catch (std::exception& e) {
30278       {
30279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30280       };
30281     } catch (...) {
30282       {
30283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30284       };
30285     }
30286   }
30287 }
30288
30289
30290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
30291   int jresult ;
30292   int result;
30293
30294   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
30295   jresult = (int)result;
30296   return jresult;
30297 }
30298
30299
30300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
30301   int jresult ;
30302   int result;
30303
30304   result = (int)Dali::Layer::Property::CLIPPING_BOX;
30305   jresult = (int)result;
30306   return jresult;
30307 }
30308
30309
30310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
30311   int jresult ;
30312   int result;
30313
30314   result = (int)Dali::Layer::Property::BEHAVIOR;
30315   jresult = (int)result;
30316   return jresult;
30317 }
30318
30319
30320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
30321   void * jresult ;
30322   Dali::Layer::Property *result = 0 ;
30323
30324   {
30325     try {
30326       result = (Dali::Layer::Property *)new Dali::Layer::Property();
30327     } catch (std::out_of_range& e) {
30328       {
30329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30330       };
30331     } catch (std::exception& e) {
30332       {
30333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30334       };
30335     } catch (...) {
30336       {
30337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30338       };
30339     }
30340   }
30341   jresult = (void *)result;
30342   return jresult;
30343 }
30344
30345
30346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
30347   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
30348
30349   arg1 = (Dali::Layer::Property *)jarg1;
30350   {
30351     try {
30352       delete arg1;
30353     } catch (std::out_of_range& e) {
30354       {
30355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30356       };
30357     } catch (std::exception& e) {
30358       {
30359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30360       };
30361     } catch (...) {
30362       {
30363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30364       };
30365     }
30366   }
30367 }
30368
30369
30370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
30371   void * jresult ;
30372   Dali::Layer *result = 0 ;
30373
30374   {
30375     try {
30376       result = (Dali::Layer *)new Dali::Layer();
30377     } catch (std::out_of_range& e) {
30378       {
30379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30380       };
30381     } catch (std::exception& e) {
30382       {
30383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30384       };
30385     } catch (...) {
30386       {
30387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30388       };
30389     }
30390   }
30391   jresult = (void *)result;
30392   return jresult;
30393 }
30394
30395
30396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
30397   void * jresult ;
30398   Dali::Layer result;
30399
30400   {
30401     try {
30402       result = Dali::Layer::New();
30403     } catch (std::out_of_range& e) {
30404       {
30405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30406       };
30407     } catch (std::exception& e) {
30408       {
30409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30410       };
30411     } catch (...) {
30412       {
30413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30414       };
30415     }
30416   }
30417   jresult = new Dali::Layer((const Dali::Layer &)result);
30418   return jresult;
30419 }
30420
30421
30422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
30423   void * jresult ;
30424   Dali::BaseHandle arg1 ;
30425   Dali::BaseHandle *argp1 ;
30426   Dali::Layer result;
30427
30428   argp1 = (Dali::BaseHandle *)jarg1;
30429   if (!argp1) {
30430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30431     return 0;
30432   }
30433   arg1 = *argp1;
30434   {
30435     try {
30436       result = Dali::Layer::DownCast(arg1);
30437     } catch (std::out_of_range& e) {
30438       {
30439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30440       };
30441     } catch (std::exception& e) {
30442       {
30443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30444       };
30445     } catch (...) {
30446       {
30447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30448       };
30449     }
30450   }
30451   jresult = new Dali::Layer((const Dali::Layer &)result);
30452   return jresult;
30453 }
30454
30455
30456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
30457   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30458
30459   arg1 = (Dali::Layer *)jarg1;
30460   {
30461     try {
30462       delete arg1;
30463     } catch (std::out_of_range& e) {
30464       {
30465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30466       };
30467     } catch (std::exception& e) {
30468       {
30469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30470       };
30471     } catch (...) {
30472       {
30473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30474       };
30475     }
30476   }
30477 }
30478
30479
30480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
30481   void * jresult ;
30482   Dali::Layer *arg1 = 0 ;
30483   Dali::Layer *result = 0 ;
30484
30485   arg1 = (Dali::Layer *)jarg1;
30486   if (!arg1) {
30487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
30488     return 0;
30489   }
30490   {
30491     try {
30492       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
30493     } catch (std::out_of_range& e) {
30494       {
30495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30496       };
30497     } catch (std::exception& e) {
30498       {
30499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30500       };
30501     } catch (...) {
30502       {
30503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30504       };
30505     }
30506   }
30507   jresult = (void *)result;
30508   return jresult;
30509 }
30510
30511
30512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
30513   void * jresult ;
30514   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30515   Dali::Layer *arg2 = 0 ;
30516   Dali::Layer *result = 0 ;
30517
30518   arg1 = (Dali::Layer *)jarg1;
30519   arg2 = (Dali::Layer *)jarg2;
30520   if (!arg2) {
30521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
30522     return 0;
30523   }
30524   {
30525     try {
30526       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
30527     } catch (std::out_of_range& e) {
30528       {
30529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30530       };
30531     } catch (std::exception& e) {
30532       {
30533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30534       };
30535     } catch (...) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30538       };
30539     }
30540   }
30541   jresult = (void *)result;
30542   return jresult;
30543 }
30544
30545
30546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
30547   unsigned int jresult ;
30548   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30549   unsigned int result;
30550
30551   arg1 = (Dali::Layer *)jarg1;
30552   {
30553     try {
30554       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
30555     } catch (std::out_of_range& e) {
30556       {
30557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30558       };
30559     } catch (std::exception& e) {
30560       {
30561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30562       };
30563     } catch (...) {
30564       {
30565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30566       };
30567     }
30568   }
30569   jresult = result;
30570   return jresult;
30571 }
30572
30573
30574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
30575   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30576
30577   arg1 = (Dali::Layer *)jarg1;
30578   {
30579     try {
30580       (arg1)->Raise();
30581     } catch (std::out_of_range& e) {
30582       {
30583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30584       };
30585     } catch (std::exception& e) {
30586       {
30587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30588       };
30589     } catch (...) {
30590       {
30591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30592       };
30593     }
30594   }
30595 }
30596
30597
30598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
30599   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30600
30601   arg1 = (Dali::Layer *)jarg1;
30602   {
30603     try {
30604       (arg1)->Lower();
30605     } catch (std::out_of_range& e) {
30606       {
30607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30608       };
30609     } catch (std::exception& e) {
30610       {
30611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30612       };
30613     } catch (...) {
30614       {
30615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30616       };
30617     }
30618   }
30619 }
30620
30621
30622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
30623   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30624   Dali::Layer arg2 ;
30625   Dali::Layer *argp2 ;
30626
30627   arg1 = (Dali::Layer *)jarg1;
30628   argp2 = (Dali::Layer *)jarg2;
30629   if (!argp2) {
30630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
30631     return ;
30632   }
30633   arg2 = *argp2;
30634   {
30635     try {
30636       (arg1)->RaiseAbove(arg2);
30637     } catch (std::out_of_range& e) {
30638       {
30639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30640       };
30641     } catch (std::exception& e) {
30642       {
30643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30644       };
30645     } catch (...) {
30646       {
30647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30648       };
30649     }
30650   }
30651 }
30652
30653
30654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
30655   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30656   Dali::Layer arg2 ;
30657   Dali::Layer *argp2 ;
30658
30659   arg1 = (Dali::Layer *)jarg1;
30660   argp2 = (Dali::Layer *)jarg2;
30661   if (!argp2) {
30662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
30663     return ;
30664   }
30665   arg2 = *argp2;
30666   {
30667     try {
30668       (arg1)->LowerBelow(arg2);
30669     } catch (std::out_of_range& e) {
30670       {
30671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30672       };
30673     } catch (std::exception& e) {
30674       {
30675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30676       };
30677     } catch (...) {
30678       {
30679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30680       };
30681     }
30682   }
30683 }
30684
30685
30686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
30687   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30688
30689   arg1 = (Dali::Layer *)jarg1;
30690   {
30691     try {
30692       (arg1)->RaiseToTop();
30693     } catch (std::out_of_range& e) {
30694       {
30695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30696       };
30697     } catch (std::exception& e) {
30698       {
30699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30700       };
30701     } catch (...) {
30702       {
30703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30704       };
30705     }
30706   }
30707 }
30708
30709
30710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
30711   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30712
30713   arg1 = (Dali::Layer *)jarg1;
30714   {
30715     try {
30716       (arg1)->LowerToBottom();
30717     } catch (std::out_of_range& e) {
30718       {
30719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30720       };
30721     } catch (std::exception& e) {
30722       {
30723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30724       };
30725     } catch (...) {
30726       {
30727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30728       };
30729     }
30730   }
30731 }
30732
30733
30734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
30735   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30736   Dali::Layer arg2 ;
30737   Dali::Layer *argp2 ;
30738
30739   arg1 = (Dali::Layer *)jarg1;
30740   argp2 = (Dali::Layer *)jarg2;
30741   if (!argp2) {
30742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
30743     return ;
30744   }
30745   arg2 = *argp2;
30746   {
30747     try {
30748       (arg1)->MoveAbove(arg2);
30749     } catch (std::out_of_range& e) {
30750       {
30751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30752       };
30753     } catch (std::exception& e) {
30754       {
30755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30756       };
30757     } catch (...) {
30758       {
30759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30760       };
30761     }
30762   }
30763 }
30764
30765
30766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
30767   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30768   Dali::Layer arg2 ;
30769   Dali::Layer *argp2 ;
30770
30771   arg1 = (Dali::Layer *)jarg1;
30772   argp2 = (Dali::Layer *)jarg2;
30773   if (!argp2) {
30774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
30775     return ;
30776   }
30777   arg2 = *argp2;
30778   {
30779     try {
30780       (arg1)->MoveBelow(arg2);
30781     } catch (std::out_of_range& e) {
30782       {
30783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30784       };
30785     } catch (std::exception& e) {
30786       {
30787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30788       };
30789     } catch (...) {
30790       {
30791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30792       };
30793     }
30794   }
30795 }
30796
30797
30798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
30799   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30800   Dali::Layer::Behavior arg2 ;
30801
30802   arg1 = (Dali::Layer *)jarg1;
30803   arg2 = (Dali::Layer::Behavior)jarg2;
30804   {
30805     try {
30806       (arg1)->SetBehavior(arg2);
30807     } catch (std::out_of_range& e) {
30808       {
30809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30810       };
30811     } catch (std::exception& e) {
30812       {
30813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30814       };
30815     } catch (...) {
30816       {
30817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30818       };
30819     }
30820   }
30821 }
30822
30823
30824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
30825   int jresult ;
30826   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30827   Dali::Layer::Behavior result;
30828
30829   arg1 = (Dali::Layer *)jarg1;
30830   {
30831     try {
30832       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
30833     } catch (std::out_of_range& e) {
30834       {
30835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30836       };
30837     } catch (std::exception& e) {
30838       {
30839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30840       };
30841     } catch (...) {
30842       {
30843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30844       };
30845     }
30846   }
30847   jresult = (int)result;
30848   return jresult;
30849 }
30850
30851
30852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
30853   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30854   bool arg2 ;
30855
30856   arg1 = (Dali::Layer *)jarg1;
30857   arg2 = jarg2 ? true : false;
30858   {
30859     try {
30860       (arg1)->SetClipping(arg2);
30861     } catch (std::out_of_range& e) {
30862       {
30863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30864       };
30865     } catch (std::exception& e) {
30866       {
30867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30868       };
30869     } catch (...) {
30870       {
30871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30872       };
30873     }
30874   }
30875 }
30876
30877
30878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
30879   unsigned int jresult ;
30880   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30881   bool result;
30882
30883   arg1 = (Dali::Layer *)jarg1;
30884   {
30885     try {
30886       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
30887     } catch (std::out_of_range& e) {
30888       {
30889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30890       };
30891     } catch (std::exception& e) {
30892       {
30893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30894       };
30895     } catch (...) {
30896       {
30897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30898       };
30899     }
30900   }
30901   jresult = result;
30902   return jresult;
30903 }
30904
30905
30906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
30907   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30908   int arg2 ;
30909   int arg3 ;
30910   int arg4 ;
30911   int arg5 ;
30912
30913   arg1 = (Dali::Layer *)jarg1;
30914   arg2 = (int)jarg2;
30915   arg3 = (int)jarg3;
30916   arg4 = (int)jarg4;
30917   arg5 = (int)jarg5;
30918   {
30919     try {
30920       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
30921     } catch (std::out_of_range& e) {
30922       {
30923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30924       };
30925     } catch (std::exception& e) {
30926       {
30927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30928       };
30929     } catch (...) {
30930       {
30931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30932       };
30933     }
30934   }
30935 }
30936
30937
30938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
30939   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30940   Dali::ClippingBox arg2 ;
30941   Dali::ClippingBox *argp2 ;
30942
30943   arg1 = (Dali::Layer *)jarg1;
30944   argp2 = (Dali::ClippingBox *)jarg2;
30945   if (!argp2) {
30946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
30947     return ;
30948   }
30949   arg2 = *argp2;
30950   {
30951     try {
30952       (arg1)->SetClippingBox(arg2);
30953     } catch (std::out_of_range& e) {
30954       {
30955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30956       };
30957     } catch (std::exception& e) {
30958       {
30959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30960       };
30961     } catch (...) {
30962       {
30963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30964       };
30965     }
30966   }
30967 }
30968
30969
30970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
30971   void * jresult ;
30972   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
30973   Dali::ClippingBox result;
30974
30975   arg1 = (Dali::Layer *)jarg1;
30976   {
30977     try {
30978       result = ((Dali::Layer const *)arg1)->GetClippingBox();
30979     } catch (std::out_of_range& e) {
30980       {
30981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30982       };
30983     } catch (std::exception& e) {
30984       {
30985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30986       };
30987     } catch (...) {
30988       {
30989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30990       };
30991     }
30992   }
30993   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
30994   return jresult;
30995 }
30996
30997
30998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
30999   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
31000   bool arg2 ;
31001
31002   arg1 = (Dali::Layer *)jarg1;
31003   arg2 = jarg2 ? true : false;
31004   {
31005     try {
31006       (arg1)->SetDepthTestDisabled(arg2);
31007     } catch (std::out_of_range& e) {
31008       {
31009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31010       };
31011     } catch (std::exception& e) {
31012       {
31013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31014       };
31015     } catch (...) {
31016       {
31017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31018       };
31019     }
31020   }
31021 }
31022
31023
31024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
31025   unsigned int jresult ;
31026   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
31027   bool result;
31028
31029   arg1 = (Dali::Layer *)jarg1;
31030   {
31031     try {
31032       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
31033     } catch (std::out_of_range& e) {
31034       {
31035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31036       };
31037     } catch (std::exception& e) {
31038       {
31039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31040       };
31041     } catch (...) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31044       };
31045     }
31046   }
31047   jresult = result;
31048   return jresult;
31049 }
31050
31051
31052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
31053   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
31054   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
31055
31056   arg1 = (Dali::Layer *)jarg1;
31057   arg2 = (Dali::Layer::SortFunctionType)jarg2;
31058   {
31059     try {
31060       (arg1)->SetSortFunction(arg2);
31061     } catch (std::out_of_range& e) {
31062       {
31063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31064       };
31065     } catch (std::exception& e) {
31066       {
31067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31068       };
31069     } catch (...) {
31070       {
31071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31072       };
31073     }
31074   }
31075 }
31076
31077
31078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
31079   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
31080   bool arg2 ;
31081
31082   arg1 = (Dali::Layer *)jarg1;
31083   arg2 = jarg2 ? true : false;
31084   {
31085     try {
31086       (arg1)->SetTouchConsumed(arg2);
31087     } catch (std::out_of_range& e) {
31088       {
31089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31090       };
31091     } catch (std::exception& e) {
31092       {
31093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31094       };
31095     } catch (...) {
31096       {
31097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31098       };
31099     }
31100   }
31101 }
31102
31103
31104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
31105   unsigned int jresult ;
31106   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
31107   bool result;
31108
31109   arg1 = (Dali::Layer *)jarg1;
31110   {
31111     try {
31112       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
31113     } catch (std::out_of_range& e) {
31114       {
31115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31116       };
31117     } catch (std::exception& e) {
31118       {
31119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31120       };
31121     } catch (...) {
31122       {
31123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31124       };
31125     }
31126   }
31127   jresult = result;
31128   return jresult;
31129 }
31130
31131
31132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
31133   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
31134   bool arg2 ;
31135
31136   arg1 = (Dali::Layer *)jarg1;
31137   arg2 = jarg2 ? true : false;
31138   {
31139     try {
31140       (arg1)->SetHoverConsumed(arg2);
31141     } catch (std::out_of_range& e) {
31142       {
31143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31144       };
31145     } catch (std::exception& e) {
31146       {
31147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31148       };
31149     } catch (...) {
31150       {
31151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31152       };
31153     }
31154   }
31155 }
31156
31157
31158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
31159   unsigned int jresult ;
31160   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
31161   bool result;
31162
31163   arg1 = (Dali::Layer *)jarg1;
31164   {
31165     try {
31166       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
31167     } catch (std::out_of_range& e) {
31168       {
31169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31170       };
31171     } catch (std::exception& e) {
31172       {
31173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31174       };
31175     } catch (...) {
31176       {
31177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31178       };
31179     }
31180   }
31181   jresult = result;
31182   return jresult;
31183 }
31184
31185
31186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
31187   void * jresult ;
31188   Dali::Vector4 *result = 0 ;
31189
31190   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
31191   jresult = (void *)result;
31192   return jresult;
31193 }
31194
31195
31196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
31197   void * jresult ;
31198   Dali::Vector4 *result = 0 ;
31199
31200   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
31201   jresult = (void *)result;
31202   return jresult;
31203 }
31204
31205
31206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
31207   void * jresult ;
31208   Dali::Stage *result = 0 ;
31209
31210   {
31211     try {
31212       result = (Dali::Stage *)new Dali::Stage();
31213     } catch (std::out_of_range& e) {
31214       {
31215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31216       };
31217     } catch (std::exception& e) {
31218       {
31219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31220       };
31221     } catch (...) {
31222       {
31223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31224       };
31225     }
31226   }
31227   jresult = (void *)result;
31228   return jresult;
31229 }
31230
31231
31232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
31233   void * jresult ;
31234   Dali::Stage result;
31235
31236   {
31237     try {
31238       result = Dali::Stage::GetCurrent();
31239     } catch (std::out_of_range& e) {
31240       {
31241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31242       };
31243     } catch (std::exception& e) {
31244       {
31245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31246       };
31247     } catch (...) {
31248       {
31249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31250       };
31251     }
31252   }
31253   jresult = new Dali::Stage((const Dali::Stage &)result);
31254   return jresult;
31255 }
31256
31257
31258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
31259   unsigned int jresult ;
31260   bool result;
31261
31262   {
31263     try {
31264       result = (bool)Dali::Stage::IsInstalled();
31265     } catch (std::out_of_range& e) {
31266       {
31267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31268       };
31269     } catch (std::exception& e) {
31270       {
31271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31272       };
31273     } catch (...) {
31274       {
31275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31276       };
31277     }
31278   }
31279   jresult = result;
31280   return jresult;
31281 }
31282
31283
31284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
31285   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31286
31287   arg1 = (Dali::Stage *)jarg1;
31288   {
31289     try {
31290       delete arg1;
31291     } catch (std::out_of_range& e) {
31292       {
31293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31294       };
31295     } catch (std::exception& e) {
31296       {
31297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31298       };
31299     } catch (...) {
31300       {
31301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31302       };
31303     }
31304   }
31305 }
31306
31307
31308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
31309   void * jresult ;
31310   Dali::Stage *arg1 = 0 ;
31311   Dali::Stage *result = 0 ;
31312
31313   arg1 = (Dali::Stage *)jarg1;
31314   if (!arg1) {
31315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
31316     return 0;
31317   }
31318   {
31319     try {
31320       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
31321     } catch (std::out_of_range& e) {
31322       {
31323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31324       };
31325     } catch (std::exception& e) {
31326       {
31327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31328       };
31329     } catch (...) {
31330       {
31331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31332       };
31333     }
31334   }
31335   jresult = (void *)result;
31336   return jresult;
31337 }
31338
31339
31340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
31341   void * jresult ;
31342   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31343   Dali::Stage *arg2 = 0 ;
31344   Dali::Stage *result = 0 ;
31345
31346   arg1 = (Dali::Stage *)jarg1;
31347   arg2 = (Dali::Stage *)jarg2;
31348   if (!arg2) {
31349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
31350     return 0;
31351   }
31352   {
31353     try {
31354       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
31355     } catch (std::out_of_range& e) {
31356       {
31357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31358       };
31359     } catch (std::exception& e) {
31360       {
31361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31362       };
31363     } catch (...) {
31364       {
31365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31366       };
31367     }
31368   }
31369   jresult = (void *)result;
31370   return jresult;
31371 }
31372
31373
31374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
31375   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31376   Dali::Actor *arg2 = 0 ;
31377
31378   arg1 = (Dali::Stage *)jarg1;
31379   arg2 = (Dali::Actor *)jarg2;
31380   if (!arg2) {
31381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
31382     return ;
31383   }
31384   {
31385     try {
31386       (arg1)->Add(*arg2);
31387     } catch (std::out_of_range& e) {
31388       {
31389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31390       };
31391     } catch (std::exception& e) {
31392       {
31393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31394       };
31395     } catch (...) {
31396       {
31397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31398       };
31399     }
31400   }
31401 }
31402
31403
31404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
31405   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31406   Dali::Actor *arg2 = 0 ;
31407
31408   arg1 = (Dali::Stage *)jarg1;
31409   arg2 = (Dali::Actor *)jarg2;
31410   if (!arg2) {
31411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
31412     return ;
31413   }
31414   {
31415     try {
31416       (arg1)->Remove(*arg2);
31417     } catch (std::out_of_range& e) {
31418       {
31419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31420       };
31421     } catch (std::exception& e) {
31422       {
31423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31424       };
31425     } catch (...) {
31426       {
31427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31428       };
31429     }
31430   }
31431 }
31432
31433
31434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
31435   void * jresult ;
31436   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31437   Dali::Vector2 result;
31438
31439   arg1 = (Dali::Stage *)jarg1;
31440   {
31441     try {
31442       result = ((Dali::Stage const *)arg1)->GetSize();
31443     } catch (std::out_of_range& e) {
31444       {
31445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31446       };
31447     } catch (std::exception& e) {
31448       {
31449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31450       };
31451     } catch (...) {
31452       {
31453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31454       };
31455     }
31456   }
31457   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31458   return jresult;
31459 }
31460
31461
31462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
31463   void * jresult ;
31464   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31465   Dali::RenderTaskList result;
31466
31467   arg1 = (Dali::Stage *)jarg1;
31468   {
31469     try {
31470       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
31471     } catch (std::out_of_range& e) {
31472       {
31473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31474       };
31475     } catch (std::exception& e) {
31476       {
31477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31478       };
31479     } catch (...) {
31480       {
31481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31482       };
31483     }
31484   }
31485   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
31486   return jresult;
31487 }
31488
31489
31490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
31491   unsigned int jresult ;
31492   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31493   unsigned int result;
31494
31495   arg1 = (Dali::Stage *)jarg1;
31496   {
31497     try {
31498       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
31499     } catch (std::out_of_range& e) {
31500       {
31501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31502       };
31503     } catch (std::exception& e) {
31504       {
31505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31506       };
31507     } catch (...) {
31508       {
31509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31510       };
31511     }
31512   }
31513   jresult = result;
31514   return jresult;
31515 }
31516
31517
31518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
31519   void * jresult ;
31520   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31521   unsigned int arg2 ;
31522   Dali::Layer result;
31523
31524   arg1 = (Dali::Stage *)jarg1;
31525   arg2 = (unsigned int)jarg2;
31526   {
31527     try {
31528       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
31529     } catch (std::out_of_range& e) {
31530       {
31531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31532       };
31533     } catch (std::exception& e) {
31534       {
31535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31536       };
31537     } catch (...) {
31538       {
31539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31540       };
31541     }
31542   }
31543   jresult = new Dali::Layer((const Dali::Layer &)result);
31544   return jresult;
31545 }
31546
31547
31548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
31549   void * jresult ;
31550   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31551   Dali::Layer result;
31552
31553   arg1 = (Dali::Stage *)jarg1;
31554   {
31555     try {
31556       result = ((Dali::Stage const *)arg1)->GetRootLayer();
31557     } catch (std::out_of_range& e) {
31558       {
31559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (std::exception& e) {
31562       {
31563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31564       };
31565     } catch (...) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31568       };
31569     }
31570   }
31571   jresult = new Dali::Layer((const Dali::Layer &)result);
31572   return jresult;
31573 }
31574
31575
31576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
31577   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31578   Dali::Vector4 arg2 ;
31579   Dali::Vector4 *argp2 ;
31580
31581   arg1 = (Dali::Stage *)jarg1;
31582   argp2 = (Dali::Vector4 *)jarg2;
31583   if (!argp2) {
31584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
31585     return ;
31586   }
31587   arg2 = *argp2;
31588   {
31589     try {
31590       (arg1)->SetBackgroundColor(arg2);
31591     } catch (std::out_of_range& e) {
31592       {
31593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31594       };
31595     } catch (std::exception& e) {
31596       {
31597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31598       };
31599     } catch (...) {
31600       {
31601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31602       };
31603     }
31604   }
31605 }
31606
31607
31608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
31609   void * jresult ;
31610   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31611   Dali::Vector4 result;
31612
31613   arg1 = (Dali::Stage *)jarg1;
31614   {
31615     try {
31616       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
31617     } catch (std::out_of_range& e) {
31618       {
31619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31620       };
31621     } catch (std::exception& e) {
31622       {
31623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31624       };
31625     } catch (...) {
31626       {
31627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31628       };
31629     }
31630   }
31631   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31632   return jresult;
31633 }
31634
31635
31636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
31637   void * jresult ;
31638   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31639   Dali::Vector2 result;
31640
31641   arg1 = (Dali::Stage *)jarg1;
31642   {
31643     try {
31644       result = ((Dali::Stage const *)arg1)->GetDpi();
31645     } catch (std::out_of_range& e) {
31646       {
31647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31648       };
31649     } catch (std::exception& e) {
31650       {
31651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31652       };
31653     } catch (...) {
31654       {
31655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31656       };
31657     }
31658   }
31659   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31660   return jresult;
31661 }
31662
31663
31664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
31665   void * jresult ;
31666   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31667   Dali::ObjectRegistry result;
31668
31669   arg1 = (Dali::Stage *)jarg1;
31670   {
31671     try {
31672       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
31673     } catch (std::out_of_range& e) {
31674       {
31675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31676       };
31677     } catch (std::exception& e) {
31678       {
31679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31680       };
31681     } catch (...) {
31682       {
31683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31684       };
31685     }
31686   }
31687   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
31688   return jresult;
31689 }
31690
31691
31692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
31693   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31694   float arg2 ;
31695
31696   arg1 = (Dali::Stage *)jarg1;
31697   arg2 = (float)jarg2;
31698   {
31699     try {
31700       (arg1)->KeepRendering(arg2);
31701     } catch (std::out_of_range& e) {
31702       {
31703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31704       };
31705     } catch (std::exception& e) {
31706       {
31707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31708       };
31709     } catch (...) {
31710       {
31711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31712       };
31713     }
31714   }
31715 }
31716
31717
31718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
31719   void * jresult ;
31720   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31721   Dali::Stage::KeyEventSignalType *result = 0 ;
31722
31723   arg1 = (Dali::Stage *)jarg1;
31724   {
31725     try {
31726       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
31727     } catch (std::out_of_range& e) {
31728       {
31729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31730       };
31731     } catch (std::exception& e) {
31732       {
31733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31734       };
31735     } catch (...) {
31736       {
31737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31738       };
31739     }
31740   }
31741   jresult = (void *)result;
31742   return jresult;
31743 }
31744
31745
31746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
31747   void * jresult ;
31748   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31749   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
31750
31751   arg1 = (Dali::Stage *)jarg1;
31752   {
31753     try {
31754       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
31755     } catch (std::out_of_range& e) {
31756       {
31757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31758       };
31759     } catch (std::exception& e) {
31760       {
31761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31762       };
31763     } catch (...) {
31764       {
31765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31766       };
31767     }
31768   }
31769   jresult = (void *)result;
31770   return jresult;
31771 }
31772
31773
31774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchedSignal(void * jarg1) {
31775   void * jresult ;
31776   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31777   Dali::Stage::TouchedSignalType *result = 0 ;
31778
31779   arg1 = (Dali::Stage *)jarg1;
31780   {
31781     try {
31782       result = (Dali::Stage::TouchedSignalType *) &(arg1)->TouchedSignal();
31783     } catch (std::out_of_range& e) {
31784       {
31785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31786       };
31787     } catch (std::exception& e) {
31788       {
31789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31790       };
31791     } catch (...) {
31792       {
31793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31794       };
31795     }
31796   }
31797   jresult = (void *)result;
31798   return jresult;
31799 }
31800
31801
31802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
31803   void * jresult ;
31804   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31805   Dali::Stage::TouchSignalType *result = 0 ;
31806
31807   arg1 = (Dali::Stage *)jarg1;
31808   {
31809     try {
31810       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
31811     } catch (std::out_of_range& e) {
31812       {
31813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31814       };
31815     } catch (std::exception& e) {
31816       {
31817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31818       };
31819     } catch (...) {
31820       {
31821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31822       };
31823     }
31824   }
31825   jresult = (void *)result;
31826   return jresult;
31827 }
31828
31829
31830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
31831   void * jresult ;
31832   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31833   Dali::Stage::WheelEventSignalType *result = 0 ;
31834
31835   arg1 = (Dali::Stage *)jarg1;
31836   {
31837     try {
31838       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
31839     } catch (std::out_of_range& e) {
31840       {
31841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31842       };
31843     } catch (std::exception& e) {
31844       {
31845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31846       };
31847     } catch (...) {
31848       {
31849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31850       };
31851     }
31852   }
31853   jresult = (void *)result;
31854   return jresult;
31855 }
31856
31857
31858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
31859   void * jresult ;
31860   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31861   Dali::Stage::ContextStatusSignal *result = 0 ;
31862
31863   arg1 = (Dali::Stage *)jarg1;
31864   {
31865     try {
31866       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
31867     } catch (std::out_of_range& e) {
31868       {
31869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31870       };
31871     } catch (std::exception& e) {
31872       {
31873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31874       };
31875     } catch (...) {
31876       {
31877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31878       };
31879     }
31880   }
31881   jresult = (void *)result;
31882   return jresult;
31883 }
31884
31885
31886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
31887   void * jresult ;
31888   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31889   Dali::Stage::ContextStatusSignal *result = 0 ;
31890
31891   arg1 = (Dali::Stage *)jarg1;
31892   {
31893     try {
31894       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
31895     } catch (std::out_of_range& e) {
31896       {
31897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31898       };
31899     } catch (std::exception& e) {
31900       {
31901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31902       };
31903     } catch (...) {
31904       {
31905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31906       };
31907     }
31908   }
31909   jresult = (void *)result;
31910   return jresult;
31911 }
31912
31913
31914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
31915   void * jresult ;
31916   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
31917   Dali::Stage::SceneCreatedSignalType *result = 0 ;
31918
31919   arg1 = (Dali::Stage *)jarg1;
31920   {
31921     try {
31922       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
31923     } catch (std::out_of_range& e) {
31924       {
31925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31926       };
31927     } catch (std::exception& e) {
31928       {
31929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31930       };
31931     } catch (...) {
31932       {
31933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31934       };
31935     }
31936   }
31937   jresult = (void *)result;
31938   return jresult;
31939 }
31940
31941
31942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
31943   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
31944
31945   arg1 = (Dali::RelayoutContainer *)jarg1;
31946   {
31947     try {
31948       delete arg1;
31949     } catch (std::out_of_range& e) {
31950       {
31951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31952       };
31953     } catch (std::exception& e) {
31954       {
31955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31956       };
31957     } catch (...) {
31958       {
31959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31960       };
31961     }
31962   }
31963 }
31964
31965
31966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
31967   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
31968   Dali::Actor *arg2 = 0 ;
31969   Dali::Vector2 *arg3 = 0 ;
31970
31971   arg1 = (Dali::RelayoutContainer *)jarg1;
31972   arg2 = (Dali::Actor *)jarg2;
31973   if (!arg2) {
31974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
31975     return ;
31976   }
31977   arg3 = (Dali::Vector2 *)jarg3;
31978   if (!arg3) {
31979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31980     return ;
31981   }
31982   {
31983     try {
31984       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
31985     } catch (std::out_of_range& e) {
31986       {
31987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31988       };
31989     } catch (std::exception& e) {
31990       {
31991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31992       };
31993     } catch (...) {
31994       {
31995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31996       };
31997     }
31998   }
31999 }
32000
32001
32002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActorImpl(void * jarg1) {
32003   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32004
32005   arg1 = (Dali::CustomActorImpl *)jarg1;
32006   {
32007     try {
32008       delete arg1;
32009     } catch (std::out_of_range& e) {
32010       {
32011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32012       };
32013     } catch (std::exception& e) {
32014       {
32015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32016       };
32017     } catch (...) {
32018       {
32019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32020       };
32021     }
32022   }
32023 }
32024
32025
32026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
32027   void * jresult ;
32028   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32029   Dali::CustomActor result;
32030
32031   arg1 = (Dali::CustomActorImpl *)jarg1;
32032   {
32033     try {
32034       result = ((Dali::CustomActorImpl const *)arg1)->Self();
32035     } catch (std::out_of_range& e) {
32036       {
32037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32038       };
32039     } catch (std::exception& e) {
32040       {
32041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32042       };
32043     } catch (...) {
32044       {
32045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32046       };
32047     }
32048   }
32049   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
32050   return jresult;
32051 }
32052
32053
32054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
32055   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32056   int arg2 ;
32057
32058   arg1 = (Dali::CustomActorImpl *)jarg1;
32059   arg2 = (int)jarg2;
32060   {
32061     try {
32062       (arg1)->OnStageConnection(arg2);
32063     } catch (std::out_of_range& e) {
32064       {
32065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32066       };
32067     } catch (std::exception& e) {
32068       {
32069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32070       };
32071     } catch (...) {
32072       {
32073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32074       };
32075     }
32076   }
32077 }
32078
32079
32080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
32081   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32082
32083   arg1 = (Dali::CustomActorImpl *)jarg1;
32084   {
32085     try {
32086       (arg1)->OnStageDisconnection();
32087     } catch (std::out_of_range& e) {
32088       {
32089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32090       };
32091     } catch (std::exception& e) {
32092       {
32093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32094       };
32095     } catch (...) {
32096       {
32097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32098       };
32099     }
32100   }
32101 }
32102
32103
32104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
32105   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32106   Dali::Actor *arg2 = 0 ;
32107
32108   arg1 = (Dali::CustomActorImpl *)jarg1;
32109   arg2 = (Dali::Actor *)jarg2;
32110   if (!arg2) {
32111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32112     return ;
32113   }
32114   {
32115     try {
32116       (arg1)->OnChildAdd(*arg2);
32117     } catch (std::out_of_range& e) {
32118       {
32119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32120       };
32121     } catch (std::exception& e) {
32122       {
32123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32124       };
32125     } catch (...) {
32126       {
32127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32128       };
32129     }
32130   }
32131 }
32132
32133
32134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
32135   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32136   Dali::Actor *arg2 = 0 ;
32137
32138   arg1 = (Dali::CustomActorImpl *)jarg1;
32139   arg2 = (Dali::Actor *)jarg2;
32140   if (!arg2) {
32141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32142     return ;
32143   }
32144   {
32145     try {
32146       (arg1)->OnChildRemove(*arg2);
32147     } catch (std::out_of_range& e) {
32148       {
32149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32150       };
32151     } catch (std::exception& e) {
32152       {
32153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32154       };
32155     } catch (...) {
32156       {
32157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32158       };
32159     }
32160   }
32161 }
32162
32163
32164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
32165   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32166   Dali::Property::Index arg2 ;
32167   Dali::Property::Value arg3 ;
32168   Dali::Property::Value *argp3 ;
32169
32170   arg1 = (Dali::CustomActorImpl *)jarg1;
32171   arg2 = (Dali::Property::Index)jarg2;
32172   argp3 = (Dali::Property::Value *)jarg3;
32173   if (!argp3) {
32174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
32175     return ;
32176   }
32177   arg3 = *argp3;
32178   {
32179     try {
32180       (arg1)->OnPropertySet(arg2,arg3);
32181     } catch (std::out_of_range& e) {
32182       {
32183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32184       };
32185     } catch (std::exception& e) {
32186       {
32187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32188       };
32189     } catch (...) {
32190       {
32191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32192       };
32193     }
32194   }
32195 }
32196
32197
32198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
32199   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32200   Dali::Vector3 *arg2 = 0 ;
32201
32202   arg1 = (Dali::CustomActorImpl *)jarg1;
32203   arg2 = (Dali::Vector3 *)jarg2;
32204   if (!arg2) {
32205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
32206     return ;
32207   }
32208   {
32209     try {
32210       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
32211     } catch (std::out_of_range& e) {
32212       {
32213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32214       };
32215     } catch (std::exception& e) {
32216       {
32217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32218       };
32219     } catch (...) {
32220       {
32221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32222       };
32223     }
32224   }
32225 }
32226
32227
32228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
32229   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32230   Dali::Animation *arg2 = 0 ;
32231   Dali::Vector3 *arg3 = 0 ;
32232
32233   arg1 = (Dali::CustomActorImpl *)jarg1;
32234   arg2 = (Dali::Animation *)jarg2;
32235   if (!arg2) {
32236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
32237     return ;
32238   }
32239   arg3 = (Dali::Vector3 *)jarg3;
32240   if (!arg3) {
32241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
32242     return ;
32243   }
32244   {
32245     try {
32246       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
32247     } catch (std::out_of_range& e) {
32248       {
32249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32250       };
32251     } catch (std::exception& e) {
32252       {
32253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32254       };
32255     } catch (...) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32258       };
32259     }
32260   }
32261 }
32262
32263
32264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
32265   unsigned int jresult ;
32266   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32267   Dali::TouchEvent *arg2 = 0 ;
32268   bool result;
32269
32270   arg1 = (Dali::CustomActorImpl *)jarg1;
32271   arg2 = (Dali::TouchEvent *)jarg2;
32272   if (!arg2) {
32273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
32274     return 0;
32275   }
32276   {
32277     try {
32278       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
32279     } catch (std::out_of_range& e) {
32280       {
32281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32282       };
32283     } catch (std::exception& e) {
32284       {
32285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32286       };
32287     } catch (...) {
32288       {
32289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32290       };
32291     }
32292   }
32293   jresult = result;
32294   return jresult;
32295 }
32296
32297
32298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
32299   unsigned int jresult ;
32300   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32301   Dali::HoverEvent *arg2 = 0 ;
32302   bool result;
32303
32304   arg1 = (Dali::CustomActorImpl *)jarg1;
32305   arg2 = (Dali::HoverEvent *)jarg2;
32306   if (!arg2) {
32307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
32308     return 0;
32309   }
32310   {
32311     try {
32312       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
32313     } catch (std::out_of_range& e) {
32314       {
32315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32316       };
32317     } catch (std::exception& e) {
32318       {
32319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32320       };
32321     } catch (...) {
32322       {
32323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32324       };
32325     }
32326   }
32327   jresult = result;
32328   return jresult;
32329 }
32330
32331
32332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
32333   unsigned int jresult ;
32334   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32335   Dali::KeyEvent *arg2 = 0 ;
32336   bool result;
32337
32338   arg1 = (Dali::CustomActorImpl *)jarg1;
32339   arg2 = (Dali::KeyEvent *)jarg2;
32340   if (!arg2) {
32341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32342     return 0;
32343   }
32344   {
32345     try {
32346       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
32347     } catch (std::out_of_range& e) {
32348       {
32349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32350       };
32351     } catch (std::exception& e) {
32352       {
32353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32354       };
32355     } catch (...) {
32356       {
32357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32358       };
32359     }
32360   }
32361   jresult = result;
32362   return jresult;
32363 }
32364
32365
32366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
32367   unsigned int jresult ;
32368   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32369   Dali::WheelEvent *arg2 = 0 ;
32370   bool result;
32371
32372   arg1 = (Dali::CustomActorImpl *)jarg1;
32373   arg2 = (Dali::WheelEvent *)jarg2;
32374   if (!arg2) {
32375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32376     return 0;
32377   }
32378   {
32379     try {
32380       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
32381     } catch (std::out_of_range& e) {
32382       {
32383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32384       };
32385     } catch (std::exception& e) {
32386       {
32387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32388       };
32389     } catch (...) {
32390       {
32391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32392       };
32393     }
32394   }
32395   jresult = result;
32396   return jresult;
32397 }
32398
32399
32400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
32401   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32402   Dali::Vector2 *arg2 = 0 ;
32403   Dali::RelayoutContainer *arg3 = 0 ;
32404
32405   arg1 = (Dali::CustomActorImpl *)jarg1;
32406   arg2 = (Dali::Vector2 *)jarg2;
32407   if (!arg2) {
32408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32409     return ;
32410   }
32411   arg3 = (Dali::RelayoutContainer *)jarg3;
32412   if (!arg3) {
32413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
32414     return ;
32415   }
32416   {
32417     try {
32418       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
32419     } catch (std::out_of_range& e) {
32420       {
32421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32422       };
32423     } catch (std::exception& e) {
32424       {
32425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32426       };
32427     } catch (...) {
32428       {
32429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32430       };
32431     }
32432   }
32433 }
32434
32435
32436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
32437   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32438   Dali::ResizePolicy::Type arg2 ;
32439   Dali::Dimension::Type arg3 ;
32440
32441   arg1 = (Dali::CustomActorImpl *)jarg1;
32442   arg2 = (Dali::ResizePolicy::Type)jarg2;
32443   arg3 = (Dali::Dimension::Type)jarg3;
32444   {
32445     try {
32446       (arg1)->OnSetResizePolicy(arg2,arg3);
32447     } catch (std::out_of_range& e) {
32448       {
32449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32450       };
32451     } catch (std::exception& e) {
32452       {
32453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32454       };
32455     } catch (...) {
32456       {
32457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32458       };
32459     }
32460   }
32461 }
32462
32463
32464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
32465   void * jresult ;
32466   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32467   Dali::Vector3 result;
32468
32469   arg1 = (Dali::CustomActorImpl *)jarg1;
32470   {
32471     try {
32472       result = (arg1)->GetNaturalSize();
32473     } catch (std::out_of_range& e) {
32474       {
32475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32476       };
32477     } catch (std::exception& e) {
32478       {
32479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32480       };
32481     } catch (...) {
32482       {
32483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32484       };
32485     }
32486   }
32487   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
32488   return jresult;
32489 }
32490
32491
32492 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
32493   float jresult ;
32494   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32495   Dali::Actor *arg2 = 0 ;
32496   Dali::Dimension::Type arg3 ;
32497   float result;
32498
32499   arg1 = (Dali::CustomActorImpl *)jarg1;
32500   arg2 = (Dali::Actor *)jarg2;
32501   if (!arg2) {
32502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
32503     return 0;
32504   }
32505   arg3 = (Dali::Dimension::Type)jarg3;
32506   {
32507     try {
32508       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
32509     } catch (std::out_of_range& e) {
32510       {
32511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32512       };
32513     } catch (std::exception& e) {
32514       {
32515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32516       };
32517     } catch (...) {
32518       {
32519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32520       };
32521     }
32522   }
32523   jresult = result;
32524   return jresult;
32525 }
32526
32527
32528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
32529   float jresult ;
32530   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32531   float arg2 ;
32532   float result;
32533
32534   arg1 = (Dali::CustomActorImpl *)jarg1;
32535   arg2 = (float)jarg2;
32536   {
32537     try {
32538       result = (float)(arg1)->GetHeightForWidth(arg2);
32539     } catch (std::out_of_range& e) {
32540       {
32541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32542       };
32543     } catch (std::exception& e) {
32544       {
32545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32546       };
32547     } catch (...) {
32548       {
32549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32550       };
32551     }
32552   }
32553   jresult = result;
32554   return jresult;
32555 }
32556
32557
32558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
32559   float jresult ;
32560   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32561   float arg2 ;
32562   float result;
32563
32564   arg1 = (Dali::CustomActorImpl *)jarg1;
32565   arg2 = (float)jarg2;
32566   {
32567     try {
32568       result = (float)(arg1)->GetWidthForHeight(arg2);
32569     } catch (std::out_of_range& e) {
32570       {
32571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32572       };
32573     } catch (std::exception& e) {
32574       {
32575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32576       };
32577     } catch (...) {
32578       {
32579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32580       };
32581     }
32582   }
32583   jresult = result;
32584   return jresult;
32585 }
32586
32587
32588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
32589   unsigned int jresult ;
32590   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32591   Dali::Dimension::Type arg2 ;
32592   bool result;
32593
32594   arg1 = (Dali::CustomActorImpl *)jarg1;
32595   arg2 = (Dali::Dimension::Type)jarg2;
32596   {
32597     try {
32598       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
32599     } catch (std::out_of_range& e) {
32600       {
32601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32602       };
32603     } catch (std::exception& e) {
32604       {
32605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32606       };
32607     } catch (...) {
32608       {
32609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32610       };
32611     }
32612   }
32613   jresult = result;
32614   return jresult;
32615 }
32616
32617
32618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
32619   unsigned int jresult ;
32620   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32621   bool result;
32622
32623   arg1 = (Dali::CustomActorImpl *)jarg1;
32624   {
32625     try {
32626       result = (bool)(arg1)->RelayoutDependentOnChildren();
32627     } catch (std::out_of_range& e) {
32628       {
32629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32630       };
32631     } catch (std::exception& e) {
32632       {
32633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32634       };
32635     } catch (...) {
32636       {
32637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32638       };
32639     }
32640   }
32641   jresult = result;
32642   return jresult;
32643 }
32644
32645
32646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
32647   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32648   Dali::Dimension::Type arg2 ;
32649
32650   arg1 = (Dali::CustomActorImpl *)jarg1;
32651   arg2 = (Dali::Dimension::Type)jarg2;
32652   {
32653     try {
32654       (arg1)->OnCalculateRelayoutSize(arg2);
32655     } catch (std::out_of_range& e) {
32656       {
32657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32658       };
32659     } catch (std::exception& e) {
32660       {
32661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32662       };
32663     } catch (...) {
32664       {
32665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32666       };
32667     }
32668   }
32669 }
32670
32671
32672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
32673   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32674   float arg2 ;
32675   Dali::Dimension::Type arg3 ;
32676
32677   arg1 = (Dali::CustomActorImpl *)jarg1;
32678   arg2 = (float)jarg2;
32679   arg3 = (Dali::Dimension::Type)jarg3;
32680   {
32681     try {
32682       (arg1)->OnLayoutNegotiated(arg2,arg3);
32683     } catch (std::out_of_range& e) {
32684       {
32685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32686       };
32687     } catch (std::exception& e) {
32688       {
32689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32690       };
32691     } catch (...) {
32692       {
32693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32694       };
32695     }
32696   }
32697 }
32698
32699
32700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
32701   unsigned int jresult ;
32702   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32703   bool result;
32704
32705   arg1 = (Dali::CustomActorImpl *)jarg1;
32706   {
32707     try {
32708       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
32709     } catch (std::out_of_range& e) {
32710       {
32711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32712       };
32713     } catch (std::exception& e) {
32714       {
32715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32716       };
32717     } catch (...) {
32718       {
32719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32720       };
32721     }
32722   }
32723   jresult = result;
32724   return jresult;
32725 }
32726
32727
32728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
32729   unsigned int jresult ;
32730   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32731   bool result;
32732
32733   arg1 = (Dali::CustomActorImpl *)jarg1;
32734   {
32735     try {
32736       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
32737     } catch (std::out_of_range& e) {
32738       {
32739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32740       };
32741     } catch (std::exception& e) {
32742       {
32743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32744       };
32745     } catch (...) {
32746       {
32747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32748       };
32749     }
32750   }
32751   jresult = result;
32752   return jresult;
32753 }
32754
32755
32756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
32757   unsigned int jresult ;
32758   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32759   bool result;
32760
32761   arg1 = (Dali::CustomActorImpl *)jarg1;
32762   {
32763     try {
32764       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
32765     } catch (std::out_of_range& e) {
32766       {
32767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32768       };
32769     } catch (std::exception& e) {
32770       {
32771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32772       };
32773     } catch (...) {
32774       {
32775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32776       };
32777     }
32778   }
32779   jresult = result;
32780   return jresult;
32781 }
32782
32783
32784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
32785   unsigned int jresult ;
32786   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
32787   bool result;
32788
32789   arg1 = (Dali::CustomActorImpl *)jarg1;
32790   {
32791     try {
32792       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
32793     } catch (std::out_of_range& e) {
32794       {
32795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32796       };
32797     } catch (std::exception& e) {
32798       {
32799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32800       };
32801     } catch (...) {
32802       {
32803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32804       };
32805     }
32806   }
32807   jresult = result;
32808   return jresult;
32809 }
32810
32811
32812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
32813   void * jresult ;
32814   Dali::CustomActor *result = 0 ;
32815
32816   {
32817     try {
32818       result = (Dali::CustomActor *)new Dali::CustomActor();
32819     } catch (std::out_of_range& e) {
32820       {
32821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32822       };
32823     } catch (std::exception& e) {
32824       {
32825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32826       };
32827     } catch (...) {
32828       {
32829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32830       };
32831     }
32832   }
32833   jresult = (void *)result;
32834   return jresult;
32835 }
32836
32837
32838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
32839   void * jresult ;
32840   Dali::BaseHandle arg1 ;
32841   Dali::BaseHandle *argp1 ;
32842   Dali::CustomActor result;
32843
32844   argp1 = (Dali::BaseHandle *)jarg1;
32845   if (!argp1) {
32846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32847     return 0;
32848   }
32849   arg1 = *argp1;
32850   {
32851     try {
32852       result = Dali::CustomActor::DownCast(arg1);
32853     } catch (std::out_of_range& e) {
32854       {
32855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32856       };
32857     } catch (std::exception& e) {
32858       {
32859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32860       };
32861     } catch (...) {
32862       {
32863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32864       };
32865     }
32866   }
32867   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
32868   return jresult;
32869 }
32870
32871
32872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
32873   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
32874
32875   arg1 = (Dali::CustomActor *)jarg1;
32876   {
32877     try {
32878       delete arg1;
32879     } catch (std::out_of_range& e) {
32880       {
32881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32882       };
32883     } catch (std::exception& e) {
32884       {
32885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32886       };
32887     } catch (...) {
32888       {
32889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32890       };
32891     }
32892   }
32893 }
32894
32895
32896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
32897   void * jresult ;
32898   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
32899   Dali::CustomActorImpl *result = 0 ;
32900
32901   arg1 = (Dali::CustomActor *)jarg1;
32902   {
32903     try {
32904       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
32905     } catch (std::out_of_range& e) {
32906       {
32907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32908       };
32909     } catch (std::exception& e) {
32910       {
32911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32912       };
32913     } catch (...) {
32914       {
32915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32916       };
32917     }
32918   }
32919   jresult = (void *)result;
32920   return jresult;
32921 }
32922
32923
32924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
32925   void * jresult ;
32926   Dali::CustomActorImpl *arg1 = 0 ;
32927   Dali::CustomActor *result = 0 ;
32928
32929   arg1 = (Dali::CustomActorImpl *)jarg1;
32930   if (!arg1) {
32931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
32932     return 0;
32933   }
32934   {
32935     try {
32936       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
32937     } catch (std::out_of_range& e) {
32938       {
32939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32940       };
32941     } catch (std::exception& e) {
32942       {
32943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32944       };
32945     } catch (...) {
32946       {
32947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32948       };
32949     }
32950   }
32951   jresult = (void *)result;
32952   return jresult;
32953 }
32954
32955
32956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
32957   void * jresult ;
32958   Dali::CustomActor *arg1 = 0 ;
32959   Dali::CustomActor *result = 0 ;
32960
32961   arg1 = (Dali::CustomActor *)jarg1;
32962   if (!arg1) {
32963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
32964     return 0;
32965   }
32966   {
32967     try {
32968       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
32969     } catch (std::out_of_range& e) {
32970       {
32971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32972       };
32973     } catch (std::exception& e) {
32974       {
32975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32976       };
32977     } catch (...) {
32978       {
32979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32980       };
32981     }
32982   }
32983   jresult = (void *)result;
32984   return jresult;
32985 }
32986
32987
32988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
32989   void * jresult ;
32990   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
32991   Dali::CustomActor *arg2 = 0 ;
32992   Dali::CustomActor *result = 0 ;
32993
32994   arg1 = (Dali::CustomActor *)jarg1;
32995   arg2 = (Dali::CustomActor *)jarg2;
32996   if (!arg2) {
32997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
32998     return 0;
32999   }
33000   {
33001     try {
33002       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
33003     } catch (std::out_of_range& e) {
33004       {
33005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33006       };
33007     } catch (std::exception& e) {
33008       {
33009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33010       };
33011     } catch (...) {
33012       {
33013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33014       };
33015     }
33016   }
33017   jresult = (void *)result;
33018   return jresult;
33019 }
33020
33021
33022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
33023   int jresult ;
33024   int result;
33025
33026   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
33027   jresult = (int)result;
33028   return jresult;
33029 }
33030
33031
33032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
33033   int jresult ;
33034   int result;
33035
33036   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
33037   jresult = (int)result;
33038   return jresult;
33039 }
33040
33041
33042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
33043   int jresult ;
33044   int result;
33045
33046   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
33047   jresult = (int)result;
33048   return jresult;
33049 }
33050
33051
33052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
33053   int jresult ;
33054   int result;
33055
33056   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
33057   jresult = (int)result;
33058   return jresult;
33059 }
33060
33061
33062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
33063   int jresult ;
33064   int result;
33065
33066   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
33067   jresult = (int)result;
33068   return jresult;
33069 }
33070
33071
33072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
33073   int jresult ;
33074   int result;
33075
33076   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
33077   jresult = (int)result;
33078   return jresult;
33079 }
33080
33081
33082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
33083   int jresult ;
33084   int result;
33085
33086   result = (int)Dali::PanGestureDetector::Property::PANNING;
33087   jresult = (int)result;
33088   return jresult;
33089 }
33090
33091
33092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
33093   void * jresult ;
33094   Dali::PanGestureDetector::Property *result = 0 ;
33095
33096   {
33097     try {
33098       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
33099     } catch (std::out_of_range& e) {
33100       {
33101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33102       };
33103     } catch (std::exception& e) {
33104       {
33105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33106       };
33107     } catch (...) {
33108       {
33109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33110       };
33111     }
33112   }
33113   jresult = (void *)result;
33114   return jresult;
33115 }
33116
33117
33118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
33119   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
33120
33121   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
33122   {
33123     try {
33124       delete arg1;
33125     } catch (std::out_of_range& e) {
33126       {
33127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33128       };
33129     } catch (std::exception& e) {
33130       {
33131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33132       };
33133     } catch (...) {
33134       {
33135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33136       };
33137     }
33138   }
33139 }
33140
33141
33142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
33143   void * jresult ;
33144   Dali::Radian *result = 0 ;
33145
33146   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
33147   jresult = (void *)result;
33148   return jresult;
33149 }
33150
33151
33152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
33153   void * jresult ;
33154   Dali::Radian *result = 0 ;
33155
33156   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
33157   jresult = (void *)result;
33158   return jresult;
33159 }
33160
33161
33162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
33163   void * jresult ;
33164   Dali::Radian *result = 0 ;
33165
33166   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
33167   jresult = (void *)result;
33168   return jresult;
33169 }
33170
33171
33172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
33173   void * jresult ;
33174   Dali::Radian *result = 0 ;
33175
33176   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
33177   jresult = (void *)result;
33178   return jresult;
33179 }
33180
33181
33182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
33183   void * jresult ;
33184   Dali::Radian *result = 0 ;
33185
33186   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
33187   jresult = (void *)result;
33188   return jresult;
33189 }
33190
33191
33192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
33193   void * jresult ;
33194   Dali::Radian *result = 0 ;
33195
33196   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
33197   jresult = (void *)result;
33198   return jresult;
33199 }
33200
33201
33202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
33203   void * jresult ;
33204   Dali::Radian *result = 0 ;
33205
33206   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
33207   jresult = (void *)result;
33208   return jresult;
33209 }
33210
33211
33212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
33213   void * jresult ;
33214   Dali::PanGestureDetector *result = 0 ;
33215
33216   {
33217     try {
33218       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
33219     } catch (std::out_of_range& e) {
33220       {
33221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33222       };
33223     } catch (std::exception& e) {
33224       {
33225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33226       };
33227     } catch (...) {
33228       {
33229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33230       };
33231     }
33232   }
33233   jresult = (void *)result;
33234   return jresult;
33235 }
33236
33237
33238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
33239   void * jresult ;
33240   Dali::PanGestureDetector result;
33241
33242   {
33243     try {
33244       result = Dali::PanGestureDetector::New();
33245     } catch (std::out_of_range& e) {
33246       {
33247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33248       };
33249     } catch (std::exception& e) {
33250       {
33251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33252       };
33253     } catch (...) {
33254       {
33255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33256       };
33257     }
33258   }
33259   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
33260   return jresult;
33261 }
33262
33263
33264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
33265   void * jresult ;
33266   Dali::BaseHandle arg1 ;
33267   Dali::BaseHandle *argp1 ;
33268   Dali::PanGestureDetector result;
33269
33270   argp1 = (Dali::BaseHandle *)jarg1;
33271   if (!argp1) {
33272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33273     return 0;
33274   }
33275   arg1 = *argp1;
33276   {
33277     try {
33278       result = Dali::PanGestureDetector::DownCast(arg1);
33279     } catch (std::out_of_range& e) {
33280       {
33281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33282       };
33283     } catch (std::exception& e) {
33284       {
33285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33286       };
33287     } catch (...) {
33288       {
33289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33290       };
33291     }
33292   }
33293   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
33294   return jresult;
33295 }
33296
33297
33298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
33299   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33300
33301   arg1 = (Dali::PanGestureDetector *)jarg1;
33302   {
33303     try {
33304       delete arg1;
33305     } catch (std::out_of_range& e) {
33306       {
33307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33308       };
33309     } catch (std::exception& e) {
33310       {
33311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33312       };
33313     } catch (...) {
33314       {
33315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33316       };
33317     }
33318   }
33319 }
33320
33321
33322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
33323   void * jresult ;
33324   Dali::PanGestureDetector *arg1 = 0 ;
33325   Dali::PanGestureDetector *result = 0 ;
33326
33327   arg1 = (Dali::PanGestureDetector *)jarg1;
33328   if (!arg1) {
33329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
33330     return 0;
33331   }
33332   {
33333     try {
33334       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
33335     } catch (std::out_of_range& e) {
33336       {
33337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33338       };
33339     } catch (std::exception& e) {
33340       {
33341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33342       };
33343     } catch (...) {
33344       {
33345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33346       };
33347     }
33348   }
33349   jresult = (void *)result;
33350   return jresult;
33351 }
33352
33353
33354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
33355   void * jresult ;
33356   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33357   Dali::PanGestureDetector *arg2 = 0 ;
33358   Dali::PanGestureDetector *result = 0 ;
33359
33360   arg1 = (Dali::PanGestureDetector *)jarg1;
33361   arg2 = (Dali::PanGestureDetector *)jarg2;
33362   if (!arg2) {
33363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
33364     return 0;
33365   }
33366   {
33367     try {
33368       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
33369     } catch (std::out_of_range& e) {
33370       {
33371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33372       };
33373     } catch (std::exception& e) {
33374       {
33375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33376       };
33377     } catch (...) {
33378       {
33379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33380       };
33381     }
33382   }
33383   jresult = (void *)result;
33384   return jresult;
33385 }
33386
33387
33388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
33389   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33390   unsigned int arg2 ;
33391
33392   arg1 = (Dali::PanGestureDetector *)jarg1;
33393   arg2 = (unsigned int)jarg2;
33394   {
33395     try {
33396       (arg1)->SetMinimumTouchesRequired(arg2);
33397     } catch (std::out_of_range& e) {
33398       {
33399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33400       };
33401     } catch (std::exception& e) {
33402       {
33403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33404       };
33405     } catch (...) {
33406       {
33407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33408       };
33409     }
33410   }
33411 }
33412
33413
33414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
33415   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33416   unsigned int arg2 ;
33417
33418   arg1 = (Dali::PanGestureDetector *)jarg1;
33419   arg2 = (unsigned int)jarg2;
33420   {
33421     try {
33422       (arg1)->SetMaximumTouchesRequired(arg2);
33423     } catch (std::out_of_range& e) {
33424       {
33425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33426       };
33427     } catch (std::exception& e) {
33428       {
33429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33430       };
33431     } catch (...) {
33432       {
33433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33434       };
33435     }
33436   }
33437 }
33438
33439
33440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
33441   unsigned int jresult ;
33442   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33443   unsigned int result;
33444
33445   arg1 = (Dali::PanGestureDetector *)jarg1;
33446   {
33447     try {
33448       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
33449     } catch (std::out_of_range& e) {
33450       {
33451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33452       };
33453     } catch (std::exception& e) {
33454       {
33455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33456       };
33457     } catch (...) {
33458       {
33459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33460       };
33461     }
33462   }
33463   jresult = result;
33464   return jresult;
33465 }
33466
33467
33468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
33469   unsigned int jresult ;
33470   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33471   unsigned int result;
33472
33473   arg1 = (Dali::PanGestureDetector *)jarg1;
33474   {
33475     try {
33476       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
33477     } catch (std::out_of_range& e) {
33478       {
33479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33480       };
33481     } catch (std::exception& e) {
33482       {
33483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33484       };
33485     } catch (...) {
33486       {
33487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33488       };
33489     }
33490   }
33491   jresult = result;
33492   return jresult;
33493 }
33494
33495
33496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
33497   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33498   Dali::Radian arg2 ;
33499   Dali::Radian arg3 ;
33500   Dali::Radian *argp2 ;
33501   Dali::Radian *argp3 ;
33502
33503   arg1 = (Dali::PanGestureDetector *)jarg1;
33504   argp2 = (Dali::Radian *)jarg2;
33505   if (!argp2) {
33506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33507     return ;
33508   }
33509   arg2 = *argp2;
33510   argp3 = (Dali::Radian *)jarg3;
33511   if (!argp3) {
33512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33513     return ;
33514   }
33515   arg3 = *argp3;
33516   {
33517     try {
33518       (arg1)->AddAngle(arg2,arg3);
33519     } catch (std::out_of_range& e) {
33520       {
33521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33522       };
33523     } catch (std::exception& e) {
33524       {
33525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33526       };
33527     } catch (...) {
33528       {
33529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33530       };
33531     }
33532   }
33533 }
33534
33535
33536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
33537   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33538   Dali::Radian arg2 ;
33539   Dali::Radian *argp2 ;
33540
33541   arg1 = (Dali::PanGestureDetector *)jarg1;
33542   argp2 = (Dali::Radian *)jarg2;
33543   if (!argp2) {
33544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33545     return ;
33546   }
33547   arg2 = *argp2;
33548   {
33549     try {
33550       (arg1)->AddAngle(arg2);
33551     } catch (std::out_of_range& e) {
33552       {
33553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33554       };
33555     } catch (std::exception& e) {
33556       {
33557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33558       };
33559     } catch (...) {
33560       {
33561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33562       };
33563     }
33564   }
33565 }
33566
33567
33568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
33569   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33570   Dali::Radian arg2 ;
33571   Dali::Radian arg3 ;
33572   Dali::Radian *argp2 ;
33573   Dali::Radian *argp3 ;
33574
33575   arg1 = (Dali::PanGestureDetector *)jarg1;
33576   argp2 = (Dali::Radian *)jarg2;
33577   if (!argp2) {
33578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33579     return ;
33580   }
33581   arg2 = *argp2;
33582   argp3 = (Dali::Radian *)jarg3;
33583   if (!argp3) {
33584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33585     return ;
33586   }
33587   arg3 = *argp3;
33588   {
33589     try {
33590       (arg1)->AddDirection(arg2,arg3);
33591     } catch (std::out_of_range& e) {
33592       {
33593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33594       };
33595     } catch (std::exception& e) {
33596       {
33597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33598       };
33599     } catch (...) {
33600       {
33601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33602       };
33603     }
33604   }
33605 }
33606
33607
33608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
33609   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33610   Dali::Radian arg2 ;
33611   Dali::Radian *argp2 ;
33612
33613   arg1 = (Dali::PanGestureDetector *)jarg1;
33614   argp2 = (Dali::Radian *)jarg2;
33615   if (!argp2) {
33616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33617     return ;
33618   }
33619   arg2 = *argp2;
33620   {
33621     try {
33622       (arg1)->AddDirection(arg2);
33623     } catch (std::out_of_range& e) {
33624       {
33625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33626       };
33627     } catch (std::exception& e) {
33628       {
33629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33630       };
33631     } catch (...) {
33632       {
33633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33634       };
33635     }
33636   }
33637 }
33638
33639
33640 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
33641   unsigned long jresult ;
33642   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33643   size_t result;
33644
33645   arg1 = (Dali::PanGestureDetector *)jarg1;
33646   {
33647     try {
33648       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
33649     } catch (std::out_of_range& e) {
33650       {
33651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33652       };
33653     } catch (std::exception& e) {
33654       {
33655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33656       };
33657     } catch (...) {
33658       {
33659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33660       };
33661     }
33662   }
33663   jresult = (unsigned long)result;
33664   return jresult;
33665 }
33666
33667
33668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
33669   void * jresult ;
33670   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33671   size_t arg2 ;
33672   Dali::PanGestureDetector::AngleThresholdPair result;
33673
33674   arg1 = (Dali::PanGestureDetector *)jarg1;
33675   arg2 = (size_t)jarg2;
33676   {
33677     try {
33678       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
33679     } catch (std::out_of_range& e) {
33680       {
33681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33682       };
33683     } catch (std::exception& e) {
33684       {
33685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33686       };
33687     } catch (...) {
33688       {
33689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33690       };
33691     }
33692   }
33693   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
33694   return jresult;
33695 }
33696
33697
33698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
33699   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33700
33701   arg1 = (Dali::PanGestureDetector *)jarg1;
33702   {
33703     try {
33704       (arg1)->ClearAngles();
33705     } catch (std::out_of_range& e) {
33706       {
33707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33708       };
33709     } catch (std::exception& e) {
33710       {
33711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33712       };
33713     } catch (...) {
33714       {
33715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33716       };
33717     }
33718   }
33719 }
33720
33721
33722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
33723   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33724   Dali::Radian arg2 ;
33725   Dali::Radian *argp2 ;
33726
33727   arg1 = (Dali::PanGestureDetector *)jarg1;
33728   argp2 = (Dali::Radian *)jarg2;
33729   if (!argp2) {
33730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33731     return ;
33732   }
33733   arg2 = *argp2;
33734   {
33735     try {
33736       (arg1)->RemoveAngle(arg2);
33737     } catch (std::out_of_range& e) {
33738       {
33739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33740       };
33741     } catch (std::exception& e) {
33742       {
33743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33744       };
33745     } catch (...) {
33746       {
33747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33748       };
33749     }
33750   }
33751 }
33752
33753
33754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
33755   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33756   Dali::Radian arg2 ;
33757   Dali::Radian *argp2 ;
33758
33759   arg1 = (Dali::PanGestureDetector *)jarg1;
33760   argp2 = (Dali::Radian *)jarg2;
33761   if (!argp2) {
33762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
33763     return ;
33764   }
33765   arg2 = *argp2;
33766   {
33767     try {
33768       (arg1)->RemoveDirection(arg2);
33769     } catch (std::out_of_range& e) {
33770       {
33771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33772       };
33773     } catch (std::exception& e) {
33774       {
33775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33776       };
33777     } catch (...) {
33778       {
33779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33780       };
33781     }
33782   }
33783 }
33784
33785
33786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
33787   void * jresult ;
33788   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
33789   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
33790
33791   arg1 = (Dali::PanGestureDetector *)jarg1;
33792   {
33793     try {
33794       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
33795     } catch (std::out_of_range& e) {
33796       {
33797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33798       };
33799     } catch (std::exception& e) {
33800       {
33801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33802       };
33803     } catch (...) {
33804       {
33805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33806       };
33807     }
33808   }
33809   jresult = (void *)result;
33810   return jresult;
33811 }
33812
33813
33814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
33815   Dali::PanGesture *arg1 = 0 ;
33816
33817   arg1 = (Dali::PanGesture *)jarg1;
33818   if (!arg1) {
33819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
33820     return ;
33821   }
33822   {
33823     try {
33824       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
33825     } catch (std::out_of_range& e) {
33826       {
33827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33828       };
33829     } catch (std::exception& e) {
33830       {
33831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33832       };
33833     } catch (...) {
33834       {
33835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33836       };
33837     }
33838   }
33839 }
33840
33841
33842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
33843   void * jresult ;
33844   Dali::PanGesture *result = 0 ;
33845
33846   {
33847     try {
33848       result = (Dali::PanGesture *)new Dali::PanGesture();
33849     } catch (std::out_of_range& e) {
33850       {
33851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33852       };
33853     } catch (std::exception& e) {
33854       {
33855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33856       };
33857     } catch (...) {
33858       {
33859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33860       };
33861     }
33862   }
33863   jresult = (void *)result;
33864   return jresult;
33865 }
33866
33867
33868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
33869   void * jresult ;
33870   Dali::Gesture::State arg1 ;
33871   Dali::PanGesture *result = 0 ;
33872
33873   arg1 = (Dali::Gesture::State)jarg1;
33874   {
33875     try {
33876       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
33877     } catch (std::out_of_range& e) {
33878       {
33879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33880       };
33881     } catch (std::exception& e) {
33882       {
33883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33884       };
33885     } catch (...) {
33886       {
33887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33888       };
33889     }
33890   }
33891   jresult = (void *)result;
33892   return jresult;
33893 }
33894
33895
33896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
33897   void * jresult ;
33898   Dali::PanGesture *arg1 = 0 ;
33899   Dali::PanGesture *result = 0 ;
33900
33901   arg1 = (Dali::PanGesture *)jarg1;
33902   if (!arg1) {
33903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
33904     return 0;
33905   }
33906   {
33907     try {
33908       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
33909     } catch (std::out_of_range& e) {
33910       {
33911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33912       };
33913     } catch (std::exception& e) {
33914       {
33915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33916       };
33917     } catch (...) {
33918       {
33919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33920       };
33921     }
33922   }
33923   jresult = (void *)result;
33924   return jresult;
33925 }
33926
33927
33928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
33929   void * jresult ;
33930   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
33931   Dali::PanGesture *arg2 = 0 ;
33932   Dali::PanGesture *result = 0 ;
33933
33934   arg1 = (Dali::PanGesture *)jarg1;
33935   arg2 = (Dali::PanGesture *)jarg2;
33936   if (!arg2) {
33937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
33938     return 0;
33939   }
33940   {
33941     try {
33942       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
33943     } catch (std::out_of_range& e) {
33944       {
33945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33946       };
33947     } catch (std::exception& e) {
33948       {
33949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33950       };
33951     } catch (...) {
33952       {
33953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33954       };
33955     }
33956   }
33957   jresult = (void *)result;
33958   return jresult;
33959 }
33960
33961
33962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
33963   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
33964
33965   arg1 = (Dali::PanGesture *)jarg1;
33966   {
33967     try {
33968       delete arg1;
33969     } catch (std::out_of_range& e) {
33970       {
33971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33972       };
33973     } catch (std::exception& e) {
33974       {
33975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33976       };
33977     } catch (...) {
33978       {
33979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33980       };
33981     }
33982   }
33983 }
33984
33985
33986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
33987   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
33988   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
33989
33990   arg1 = (Dali::PanGesture *)jarg1;
33991   arg2 = (Dali::Vector2 *)jarg2;
33992   if (arg1) (arg1)->velocity = *arg2;
33993 }
33994
33995
33996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
33997   void * jresult ;
33998   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
33999   Dali::Vector2 *result = 0 ;
34000
34001   arg1 = (Dali::PanGesture *)jarg1;
34002   result = (Dali::Vector2 *)& ((arg1)->velocity);
34003   jresult = (void *)result;
34004   return jresult;
34005 }
34006
34007
34008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
34009   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34010   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
34011
34012   arg1 = (Dali::PanGesture *)jarg1;
34013   arg2 = (Dali::Vector2 *)jarg2;
34014   if (arg1) (arg1)->displacement = *arg2;
34015 }
34016
34017
34018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
34019   void * jresult ;
34020   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34021   Dali::Vector2 *result = 0 ;
34022
34023   arg1 = (Dali::PanGesture *)jarg1;
34024   result = (Dali::Vector2 *)& ((arg1)->displacement);
34025   jresult = (void *)result;
34026   return jresult;
34027 }
34028
34029
34030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
34031   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34032   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
34033
34034   arg1 = (Dali::PanGesture *)jarg1;
34035   arg2 = (Dali::Vector2 *)jarg2;
34036   if (arg1) (arg1)->position = *arg2;
34037 }
34038
34039
34040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
34041   void * jresult ;
34042   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34043   Dali::Vector2 *result = 0 ;
34044
34045   arg1 = (Dali::PanGesture *)jarg1;
34046   result = (Dali::Vector2 *)& ((arg1)->position);
34047   jresult = (void *)result;
34048   return jresult;
34049 }
34050
34051
34052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
34053   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34054   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
34055
34056   arg1 = (Dali::PanGesture *)jarg1;
34057   arg2 = (Dali::Vector2 *)jarg2;
34058   if (arg1) (arg1)->screenVelocity = *arg2;
34059 }
34060
34061
34062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
34063   void * jresult ;
34064   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34065   Dali::Vector2 *result = 0 ;
34066
34067   arg1 = (Dali::PanGesture *)jarg1;
34068   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
34069   jresult = (void *)result;
34070   return jresult;
34071 }
34072
34073
34074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
34075   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34076   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
34077
34078   arg1 = (Dali::PanGesture *)jarg1;
34079   arg2 = (Dali::Vector2 *)jarg2;
34080   if (arg1) (arg1)->screenDisplacement = *arg2;
34081 }
34082
34083
34084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
34085   void * jresult ;
34086   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34087   Dali::Vector2 *result = 0 ;
34088
34089   arg1 = (Dali::PanGesture *)jarg1;
34090   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
34091   jresult = (void *)result;
34092   return jresult;
34093 }
34094
34095
34096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
34097   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34098   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
34099
34100   arg1 = (Dali::PanGesture *)jarg1;
34101   arg2 = (Dali::Vector2 *)jarg2;
34102   if (arg1) (arg1)->screenPosition = *arg2;
34103 }
34104
34105
34106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
34107   void * jresult ;
34108   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34109   Dali::Vector2 *result = 0 ;
34110
34111   arg1 = (Dali::PanGesture *)jarg1;
34112   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
34113   jresult = (void *)result;
34114   return jresult;
34115 }
34116
34117
34118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
34119   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34120   unsigned int arg2 ;
34121
34122   arg1 = (Dali::PanGesture *)jarg1;
34123   arg2 = (unsigned int)jarg2;
34124   if (arg1) (arg1)->numberOfTouches = arg2;
34125 }
34126
34127
34128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
34129   unsigned int jresult ;
34130   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34131   unsigned int result;
34132
34133   arg1 = (Dali::PanGesture *)jarg1;
34134   result = (unsigned int) ((arg1)->numberOfTouches);
34135   jresult = result;
34136   return jresult;
34137 }
34138
34139
34140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
34141   float jresult ;
34142   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34143   float result;
34144
34145   arg1 = (Dali::PanGesture *)jarg1;
34146   {
34147     try {
34148       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
34149     } catch (std::out_of_range& e) {
34150       {
34151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34152       };
34153     } catch (std::exception& e) {
34154       {
34155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34156       };
34157     } catch (...) {
34158       {
34159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34160       };
34161     }
34162   }
34163   jresult = result;
34164   return jresult;
34165 }
34166
34167
34168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
34169   float jresult ;
34170   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34171   float result;
34172
34173   arg1 = (Dali::PanGesture *)jarg1;
34174   {
34175     try {
34176       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
34177     } catch (std::out_of_range& e) {
34178       {
34179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34180       };
34181     } catch (std::exception& e) {
34182       {
34183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34184       };
34185     } catch (...) {
34186       {
34187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34188       };
34189     }
34190   }
34191   jresult = result;
34192   return jresult;
34193 }
34194
34195
34196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
34197   float jresult ;
34198   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34199   float result;
34200
34201   arg1 = (Dali::PanGesture *)jarg1;
34202   {
34203     try {
34204       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
34205     } catch (std::out_of_range& e) {
34206       {
34207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34208       };
34209     } catch (std::exception& e) {
34210       {
34211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34212       };
34213     } catch (...) {
34214       {
34215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34216       };
34217     }
34218   }
34219   jresult = result;
34220   return jresult;
34221 }
34222
34223
34224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
34225   float jresult ;
34226   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
34227   float result;
34228
34229   arg1 = (Dali::PanGesture *)jarg1;
34230   {
34231     try {
34232       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
34233     } catch (std::out_of_range& e) {
34234       {
34235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34236       };
34237     } catch (std::exception& e) {
34238       {
34239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34240       };
34241     } catch (...) {
34242       {
34243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34244       };
34245     }
34246   }
34247   jresult = result;
34248   return jresult;
34249 }
34250
34251
34252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
34253   void * jresult ;
34254   Dali::PinchGestureDetector *result = 0 ;
34255
34256   {
34257     try {
34258       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
34259     } catch (std::out_of_range& e) {
34260       {
34261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34262       };
34263     } catch (std::exception& e) {
34264       {
34265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34266       };
34267     } catch (...) {
34268       {
34269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34270       };
34271     }
34272   }
34273   jresult = (void *)result;
34274   return jresult;
34275 }
34276
34277
34278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
34279   void * jresult ;
34280   Dali::PinchGestureDetector result;
34281
34282   {
34283     try {
34284       result = Dali::PinchGestureDetector::New();
34285     } catch (std::out_of_range& e) {
34286       {
34287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34288       };
34289     } catch (std::exception& e) {
34290       {
34291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34292       };
34293     } catch (...) {
34294       {
34295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34296       };
34297     }
34298   }
34299   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
34300   return jresult;
34301 }
34302
34303
34304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
34305   void * jresult ;
34306   Dali::BaseHandle arg1 ;
34307   Dali::BaseHandle *argp1 ;
34308   Dali::PinchGestureDetector result;
34309
34310   argp1 = (Dali::BaseHandle *)jarg1;
34311   if (!argp1) {
34312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34313     return 0;
34314   }
34315   arg1 = *argp1;
34316   {
34317     try {
34318       result = Dali::PinchGestureDetector::DownCast(arg1);
34319     } catch (std::out_of_range& e) {
34320       {
34321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34322       };
34323     } catch (std::exception& e) {
34324       {
34325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34326       };
34327     } catch (...) {
34328       {
34329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34330       };
34331     }
34332   }
34333   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
34334   return jresult;
34335 }
34336
34337
34338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
34339   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
34340
34341   arg1 = (Dali::PinchGestureDetector *)jarg1;
34342   {
34343     try {
34344       delete arg1;
34345     } catch (std::out_of_range& e) {
34346       {
34347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34348       };
34349     } catch (std::exception& e) {
34350       {
34351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34352       };
34353     } catch (...) {
34354       {
34355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34356       };
34357     }
34358   }
34359 }
34360
34361
34362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
34363   void * jresult ;
34364   Dali::PinchGestureDetector *arg1 = 0 ;
34365   Dali::PinchGestureDetector *result = 0 ;
34366
34367   arg1 = (Dali::PinchGestureDetector *)jarg1;
34368   if (!arg1) {
34369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
34370     return 0;
34371   }
34372   {
34373     try {
34374       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
34375     } catch (std::out_of_range& e) {
34376       {
34377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34378       };
34379     } catch (std::exception& e) {
34380       {
34381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34382       };
34383     } catch (...) {
34384       {
34385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34386       };
34387     }
34388   }
34389   jresult = (void *)result;
34390   return jresult;
34391 }
34392
34393
34394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
34395   void * jresult ;
34396   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
34397   Dali::PinchGestureDetector *arg2 = 0 ;
34398   Dali::PinchGestureDetector *result = 0 ;
34399
34400   arg1 = (Dali::PinchGestureDetector *)jarg1;
34401   arg2 = (Dali::PinchGestureDetector *)jarg2;
34402   if (!arg2) {
34403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
34404     return 0;
34405   }
34406   {
34407     try {
34408       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
34409     } catch (std::out_of_range& e) {
34410       {
34411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34412       };
34413     } catch (std::exception& e) {
34414       {
34415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34416       };
34417     } catch (...) {
34418       {
34419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34420       };
34421     }
34422   }
34423   jresult = (void *)result;
34424   return jresult;
34425 }
34426
34427
34428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
34429   void * jresult ;
34430   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
34431   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
34432
34433   arg1 = (Dali::PinchGestureDetector *)jarg1;
34434   {
34435     try {
34436       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
34437     } catch (std::out_of_range& e) {
34438       {
34439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34440       };
34441     } catch (std::exception& e) {
34442       {
34443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34444       };
34445     } catch (...) {
34446       {
34447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34448       };
34449     }
34450   }
34451   jresult = (void *)result;
34452   return jresult;
34453 }
34454
34455
34456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
34457   void * jresult ;
34458   Dali::Gesture::State arg1 ;
34459   Dali::PinchGesture *result = 0 ;
34460
34461   arg1 = (Dali::Gesture::State)jarg1;
34462   {
34463     try {
34464       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
34465     } catch (std::out_of_range& e) {
34466       {
34467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34468       };
34469     } catch (std::exception& e) {
34470       {
34471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34472       };
34473     } catch (...) {
34474       {
34475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34476       };
34477     }
34478   }
34479   jresult = (void *)result;
34480   return jresult;
34481 }
34482
34483
34484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
34485   void * jresult ;
34486   Dali::PinchGesture *arg1 = 0 ;
34487   Dali::PinchGesture *result = 0 ;
34488
34489   arg1 = (Dali::PinchGesture *)jarg1;
34490   if (!arg1) {
34491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
34492     return 0;
34493   }
34494   {
34495     try {
34496       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
34497     } catch (std::out_of_range& e) {
34498       {
34499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34500       };
34501     } catch (std::exception& e) {
34502       {
34503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34504       };
34505     } catch (...) {
34506       {
34507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34508       };
34509     }
34510   }
34511   jresult = (void *)result;
34512   return jresult;
34513 }
34514
34515
34516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
34517   void * jresult ;
34518   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34519   Dali::PinchGesture *arg2 = 0 ;
34520   Dali::PinchGesture *result = 0 ;
34521
34522   arg1 = (Dali::PinchGesture *)jarg1;
34523   arg2 = (Dali::PinchGesture *)jarg2;
34524   if (!arg2) {
34525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
34526     return 0;
34527   }
34528   {
34529     try {
34530       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
34531     } catch (std::out_of_range& e) {
34532       {
34533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34534       };
34535     } catch (std::exception& e) {
34536       {
34537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34538       };
34539     } catch (...) {
34540       {
34541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34542       };
34543     }
34544   }
34545   jresult = (void *)result;
34546   return jresult;
34547 }
34548
34549
34550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
34551   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34552
34553   arg1 = (Dali::PinchGesture *)jarg1;
34554   {
34555     try {
34556       delete arg1;
34557     } catch (std::out_of_range& e) {
34558       {
34559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34560       };
34561     } catch (std::exception& e) {
34562       {
34563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34564       };
34565     } catch (...) {
34566       {
34567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34568       };
34569     }
34570   }
34571 }
34572
34573
34574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
34575   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34576   float arg2 ;
34577
34578   arg1 = (Dali::PinchGesture *)jarg1;
34579   arg2 = (float)jarg2;
34580   if (arg1) (arg1)->scale = arg2;
34581 }
34582
34583
34584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
34585   float jresult ;
34586   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34587   float result;
34588
34589   arg1 = (Dali::PinchGesture *)jarg1;
34590   result = (float) ((arg1)->scale);
34591   jresult = result;
34592   return jresult;
34593 }
34594
34595
34596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
34597   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34598   float arg2 ;
34599
34600   arg1 = (Dali::PinchGesture *)jarg1;
34601   arg2 = (float)jarg2;
34602   if (arg1) (arg1)->speed = arg2;
34603 }
34604
34605
34606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
34607   float jresult ;
34608   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34609   float result;
34610
34611   arg1 = (Dali::PinchGesture *)jarg1;
34612   result = (float) ((arg1)->speed);
34613   jresult = result;
34614   return jresult;
34615 }
34616
34617
34618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
34619   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34620   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
34621
34622   arg1 = (Dali::PinchGesture *)jarg1;
34623   arg2 = (Dali::Vector2 *)jarg2;
34624   if (arg1) (arg1)->screenCenterPoint = *arg2;
34625 }
34626
34627
34628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
34629   void * jresult ;
34630   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34631   Dali::Vector2 *result = 0 ;
34632
34633   arg1 = (Dali::PinchGesture *)jarg1;
34634   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
34635   jresult = (void *)result;
34636   return jresult;
34637 }
34638
34639
34640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
34641   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34642   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
34643
34644   arg1 = (Dali::PinchGesture *)jarg1;
34645   arg2 = (Dali::Vector2 *)jarg2;
34646   if (arg1) (arg1)->localCenterPoint = *arg2;
34647 }
34648
34649
34650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
34651   void * jresult ;
34652   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
34653   Dali::Vector2 *result = 0 ;
34654
34655   arg1 = (Dali::PinchGesture *)jarg1;
34656   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
34657   jresult = (void *)result;
34658   return jresult;
34659 }
34660
34661
34662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
34663   void * jresult ;
34664   Dali::TapGestureDetector *result = 0 ;
34665
34666   {
34667     try {
34668       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
34669     } catch (std::out_of_range& e) {
34670       {
34671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34672       };
34673     } catch (std::exception& e) {
34674       {
34675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34676       };
34677     } catch (...) {
34678       {
34679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34680       };
34681     }
34682   }
34683   jresult = (void *)result;
34684   return jresult;
34685 }
34686
34687
34688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
34689   void * jresult ;
34690   Dali::TapGestureDetector result;
34691
34692   {
34693     try {
34694       result = Dali::TapGestureDetector::New();
34695     } catch (std::out_of_range& e) {
34696       {
34697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34698       };
34699     } catch (std::exception& e) {
34700       {
34701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34702       };
34703     } catch (...) {
34704       {
34705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34706       };
34707     }
34708   }
34709   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
34710   return jresult;
34711 }
34712
34713
34714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
34715   void * jresult ;
34716   unsigned int arg1 ;
34717   Dali::TapGestureDetector result;
34718
34719   arg1 = (unsigned int)jarg1;
34720   {
34721     try {
34722       result = Dali::TapGestureDetector::New(arg1);
34723     } catch (std::out_of_range& e) {
34724       {
34725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34726       };
34727     } catch (std::exception& e) {
34728       {
34729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34730       };
34731     } catch (...) {
34732       {
34733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34734       };
34735     }
34736   }
34737   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
34738   return jresult;
34739 }
34740
34741
34742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
34743   void * jresult ;
34744   Dali::BaseHandle arg1 ;
34745   Dali::BaseHandle *argp1 ;
34746   Dali::TapGestureDetector result;
34747
34748   argp1 = (Dali::BaseHandle *)jarg1;
34749   if (!argp1) {
34750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34751     return 0;
34752   }
34753   arg1 = *argp1;
34754   {
34755     try {
34756       result = Dali::TapGestureDetector::DownCast(arg1);
34757     } catch (std::out_of_range& e) {
34758       {
34759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34760       };
34761     } catch (std::exception& e) {
34762       {
34763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34764       };
34765     } catch (...) {
34766       {
34767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34768       };
34769     }
34770   }
34771   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
34772   return jresult;
34773 }
34774
34775
34776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
34777   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
34778
34779   arg1 = (Dali::TapGestureDetector *)jarg1;
34780   {
34781     try {
34782       delete arg1;
34783     } catch (std::out_of_range& e) {
34784       {
34785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34786       };
34787     } catch (std::exception& e) {
34788       {
34789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34790       };
34791     } catch (...) {
34792       {
34793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34794       };
34795     }
34796   }
34797 }
34798
34799
34800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
34801   void * jresult ;
34802   Dali::TapGestureDetector *arg1 = 0 ;
34803   Dali::TapGestureDetector *result = 0 ;
34804
34805   arg1 = (Dali::TapGestureDetector *)jarg1;
34806   if (!arg1) {
34807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
34808     return 0;
34809   }
34810   {
34811     try {
34812       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
34813     } catch (std::out_of_range& e) {
34814       {
34815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34816       };
34817     } catch (std::exception& e) {
34818       {
34819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34820       };
34821     } catch (...) {
34822       {
34823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34824       };
34825     }
34826   }
34827   jresult = (void *)result;
34828   return jresult;
34829 }
34830
34831
34832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
34833   void * jresult ;
34834   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
34835   Dali::TapGestureDetector *arg2 = 0 ;
34836   Dali::TapGestureDetector *result = 0 ;
34837
34838   arg1 = (Dali::TapGestureDetector *)jarg1;
34839   arg2 = (Dali::TapGestureDetector *)jarg2;
34840   if (!arg2) {
34841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
34842     return 0;
34843   }
34844   {
34845     try {
34846       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
34847     } catch (std::out_of_range& e) {
34848       {
34849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34850       };
34851     } catch (std::exception& e) {
34852       {
34853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34854       };
34855     } catch (...) {
34856       {
34857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34858       };
34859     }
34860   }
34861   jresult = (void *)result;
34862   return jresult;
34863 }
34864
34865
34866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
34867   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
34868   unsigned int arg2 ;
34869
34870   arg1 = (Dali::TapGestureDetector *)jarg1;
34871   arg2 = (unsigned int)jarg2;
34872   {
34873     try {
34874       (arg1)->SetMinimumTapsRequired(arg2);
34875     } catch (std::out_of_range& e) {
34876       {
34877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34878       };
34879     } catch (std::exception& e) {
34880       {
34881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34882       };
34883     } catch (...) {
34884       {
34885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34886       };
34887     }
34888   }
34889 }
34890
34891
34892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
34893   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
34894   unsigned int arg2 ;
34895
34896   arg1 = (Dali::TapGestureDetector *)jarg1;
34897   arg2 = (unsigned int)jarg2;
34898   {
34899     try {
34900       (arg1)->SetMaximumTapsRequired(arg2);
34901     } catch (std::out_of_range& e) {
34902       {
34903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34904       };
34905     } catch (std::exception& e) {
34906       {
34907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34908       };
34909     } catch (...) {
34910       {
34911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34912       };
34913     }
34914   }
34915 }
34916
34917
34918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
34919   unsigned int jresult ;
34920   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
34921   unsigned int result;
34922
34923   arg1 = (Dali::TapGestureDetector *)jarg1;
34924   {
34925     try {
34926       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
34927     } catch (std::out_of_range& e) {
34928       {
34929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34930       };
34931     } catch (std::exception& e) {
34932       {
34933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34934       };
34935     } catch (...) {
34936       {
34937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34938       };
34939     }
34940   }
34941   jresult = result;
34942   return jresult;
34943 }
34944
34945
34946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
34947   unsigned int jresult ;
34948   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
34949   unsigned int result;
34950
34951   arg1 = (Dali::TapGestureDetector *)jarg1;
34952   {
34953     try {
34954       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
34955     } catch (std::out_of_range& e) {
34956       {
34957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34958       };
34959     } catch (std::exception& e) {
34960       {
34961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34962       };
34963     } catch (...) {
34964       {
34965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34966       };
34967     }
34968   }
34969   jresult = result;
34970   return jresult;
34971 }
34972
34973
34974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
34975   void * jresult ;
34976   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
34977   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
34978
34979   arg1 = (Dali::TapGestureDetector *)jarg1;
34980   {
34981     try {
34982       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
34983     } catch (std::out_of_range& e) {
34984       {
34985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34986       };
34987     } catch (std::exception& e) {
34988       {
34989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34990       };
34991     } catch (...) {
34992       {
34993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34994       };
34995     }
34996   }
34997   jresult = (void *)result;
34998   return jresult;
34999 }
35000
35001
35002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
35003   void * jresult ;
35004   Dali::TapGesture *result = 0 ;
35005
35006   {
35007     try {
35008       result = (Dali::TapGesture *)new Dali::TapGesture();
35009     } catch (std::out_of_range& e) {
35010       {
35011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35012       };
35013     } catch (std::exception& e) {
35014       {
35015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35016       };
35017     } catch (...) {
35018       {
35019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35020       };
35021     }
35022   }
35023   jresult = (void *)result;
35024   return jresult;
35025 }
35026
35027
35028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
35029   void * jresult ;
35030   Dali::TapGesture *arg1 = 0 ;
35031   Dali::TapGesture *result = 0 ;
35032
35033   arg1 = (Dali::TapGesture *)jarg1;
35034   if (!arg1) {
35035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
35036     return 0;
35037   }
35038   {
35039     try {
35040       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
35041     } catch (std::out_of_range& e) {
35042       {
35043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35044       };
35045     } catch (std::exception& e) {
35046       {
35047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35048       };
35049     } catch (...) {
35050       {
35051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35052       };
35053     }
35054   }
35055   jresult = (void *)result;
35056   return jresult;
35057 }
35058
35059
35060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
35061   void * jresult ;
35062   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35063   Dali::TapGesture *arg2 = 0 ;
35064   Dali::TapGesture *result = 0 ;
35065
35066   arg1 = (Dali::TapGesture *)jarg1;
35067   arg2 = (Dali::TapGesture *)jarg2;
35068   if (!arg2) {
35069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
35070     return 0;
35071   }
35072   {
35073     try {
35074       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
35075     } catch (std::out_of_range& e) {
35076       {
35077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35078       };
35079     } catch (std::exception& e) {
35080       {
35081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35082       };
35083     } catch (...) {
35084       {
35085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35086       };
35087     }
35088   }
35089   jresult = (void *)result;
35090   return jresult;
35091 }
35092
35093
35094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
35095   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35096
35097   arg1 = (Dali::TapGesture *)jarg1;
35098   {
35099     try {
35100       delete arg1;
35101     } catch (std::out_of_range& e) {
35102       {
35103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35104       };
35105     } catch (std::exception& e) {
35106       {
35107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35108       };
35109     } catch (...) {
35110       {
35111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35112       };
35113     }
35114   }
35115 }
35116
35117
35118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
35119   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35120   unsigned int arg2 ;
35121
35122   arg1 = (Dali::TapGesture *)jarg1;
35123   arg2 = (unsigned int)jarg2;
35124   if (arg1) (arg1)->numberOfTaps = arg2;
35125 }
35126
35127
35128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
35129   unsigned int jresult ;
35130   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35131   unsigned int result;
35132
35133   arg1 = (Dali::TapGesture *)jarg1;
35134   result = (unsigned int) ((arg1)->numberOfTaps);
35135   jresult = result;
35136   return jresult;
35137 }
35138
35139
35140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
35141   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35142   unsigned int arg2 ;
35143
35144   arg1 = (Dali::TapGesture *)jarg1;
35145   arg2 = (unsigned int)jarg2;
35146   if (arg1) (arg1)->numberOfTouches = arg2;
35147 }
35148
35149
35150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
35151   unsigned int jresult ;
35152   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35153   unsigned int result;
35154
35155   arg1 = (Dali::TapGesture *)jarg1;
35156   result = (unsigned int) ((arg1)->numberOfTouches);
35157   jresult = result;
35158   return jresult;
35159 }
35160
35161
35162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
35163   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35164   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35165
35166   arg1 = (Dali::TapGesture *)jarg1;
35167   arg2 = (Dali::Vector2 *)jarg2;
35168   if (arg1) (arg1)->screenPoint = *arg2;
35169 }
35170
35171
35172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
35173   void * jresult ;
35174   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35175   Dali::Vector2 *result = 0 ;
35176
35177   arg1 = (Dali::TapGesture *)jarg1;
35178   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
35179   jresult = (void *)result;
35180   return jresult;
35181 }
35182
35183
35184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
35185   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35186   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35187
35188   arg1 = (Dali::TapGesture *)jarg1;
35189   arg2 = (Dali::Vector2 *)jarg2;
35190   if (arg1) (arg1)->localPoint = *arg2;
35191 }
35192
35193
35194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
35195   void * jresult ;
35196   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
35197   Dali::Vector2 *result = 0 ;
35198
35199   arg1 = (Dali::TapGesture *)jarg1;
35200   result = (Dali::Vector2 *)& ((arg1)->localPoint);
35201   jresult = (void *)result;
35202   return jresult;
35203 }
35204
35205
35206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchEvent__SWIG_0() {
35207   void * jresult ;
35208   Dali::TouchEvent *result = 0 ;
35209
35210   {
35211     try {
35212       result = (Dali::TouchEvent *)new Dali::TouchEvent();
35213     } catch (std::out_of_range& e) {
35214       {
35215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35216       };
35217     } catch (std::exception& e) {
35218       {
35219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35220       };
35221     } catch (...) {
35222       {
35223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35224       };
35225     }
35226   }
35227   jresult = (void *)result;
35228   return jresult;
35229 }
35230
35231
35232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchEvent__SWIG_1(unsigned long jarg1) {
35233   void * jresult ;
35234   unsigned long arg1 ;
35235   Dali::TouchEvent *result = 0 ;
35236
35237   arg1 = (unsigned long)jarg1;
35238   {
35239     try {
35240       result = (Dali::TouchEvent *)new Dali::TouchEvent(arg1);
35241     } catch (std::out_of_range& e) {
35242       {
35243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35244       };
35245     } catch (std::exception& e) {
35246       {
35247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35248       };
35249     } catch (...) {
35250       {
35251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35252       };
35253     }
35254   }
35255   jresult = (void *)result;
35256   return jresult;
35257 }
35258
35259
35260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchEvent(void * jarg1) {
35261   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
35262
35263   arg1 = (Dali::TouchEvent *)jarg1;
35264   {
35265     try {
35266       delete arg1;
35267     } catch (std::out_of_range& e) {
35268       {
35269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35270       };
35271     } catch (std::exception& e) {
35272       {
35273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35274       };
35275     } catch (...) {
35276       {
35277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35278       };
35279     }
35280   }
35281 }
35282
35283
35284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchEvent_points_set(void * jarg1, void * jarg2) {
35285   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
35286   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
35287
35288   arg1 = (Dali::TouchEvent *)jarg1;
35289   arg2 = (Dali::TouchPointContainer *)jarg2;
35290   if (arg1) (arg1)->points = *arg2;
35291 }
35292
35293
35294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchEvent_points_get(void * jarg1) {
35295   void * jresult ;
35296   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
35297   Dali::TouchPointContainer *result = 0 ;
35298
35299   arg1 = (Dali::TouchEvent *)jarg1;
35300   result = (Dali::TouchPointContainer *)& ((arg1)->points);
35301   jresult = (void *)result;
35302   return jresult;
35303 }
35304
35305
35306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchEvent_time_set(void * jarg1, unsigned long jarg2) {
35307   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
35308   unsigned long arg2 ;
35309
35310   arg1 = (Dali::TouchEvent *)jarg1;
35311   arg2 = (unsigned long)jarg2;
35312   if (arg1) (arg1)->time = arg2;
35313 }
35314
35315
35316 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchEvent_time_get(void * jarg1) {
35317   unsigned long jresult ;
35318   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
35319   unsigned long result;
35320
35321   arg1 = (Dali::TouchEvent *)jarg1;
35322   result = (unsigned long) ((arg1)->time);
35323   jresult = (unsigned long)result;
35324   return jresult;
35325 }
35326
35327
35328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchEvent_GetPointCount(void * jarg1) {
35329   unsigned int jresult ;
35330   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
35331   unsigned int result;
35332
35333   arg1 = (Dali::TouchEvent *)jarg1;
35334   {
35335     try {
35336       result = (unsigned int)((Dali::TouchEvent const *)arg1)->GetPointCount();
35337     } catch (std::out_of_range& e) {
35338       {
35339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35340       };
35341     } catch (std::exception& e) {
35342       {
35343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35344       };
35345     } catch (...) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35348       };
35349     }
35350   }
35351   jresult = result;
35352   return jresult;
35353 }
35354
35355
35356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchEvent_GetPoint(void * jarg1, unsigned int jarg2) {
35357   void * jresult ;
35358   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
35359   unsigned int arg2 ;
35360   Dali::TouchPoint *result = 0 ;
35361
35362   arg1 = (Dali::TouchEvent *)jarg1;
35363   arg2 = (unsigned int)jarg2;
35364   {
35365     try {
35366       result = (Dali::TouchPoint *) &((Dali::TouchEvent const *)arg1)->GetPoint(arg2);
35367     } catch (std::out_of_range& e) {
35368       {
35369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35370       };
35371     } catch (std::exception& e) {
35372       {
35373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35374       };
35375     } catch (...) {
35376       {
35377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35378       };
35379     }
35380   }
35381   jresult = (void *)result;
35382   return jresult;
35383 }
35384
35385
35386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
35387   void * jresult ;
35388   Dali::AlphaFunction *result = 0 ;
35389
35390   {
35391     try {
35392       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
35393     } catch (std::out_of_range& e) {
35394       {
35395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35396       };
35397     } catch (std::exception& e) {
35398       {
35399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35400       };
35401     } catch (...) {
35402       {
35403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35404       };
35405     }
35406   }
35407   jresult = (void *)result;
35408   return jresult;
35409 }
35410
35411
35412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
35413   void * jresult ;
35414   Dali::AlphaFunction::BuiltinFunction arg1 ;
35415   Dali::AlphaFunction *result = 0 ;
35416
35417   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
35418   {
35419     try {
35420       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
35421     } catch (std::out_of_range& e) {
35422       {
35423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35424       };
35425     } catch (std::exception& e) {
35426       {
35427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35428       };
35429     } catch (...) {
35430       {
35431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35432       };
35433     }
35434   }
35435   jresult = (void *)result;
35436   return jresult;
35437 }
35438
35439
35440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
35441   void * jresult ;
35442   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
35443   Dali::AlphaFunction *result = 0 ;
35444
35445   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
35446   {
35447     try {
35448       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
35449     } catch (std::out_of_range& e) {
35450       {
35451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35452       };
35453     } catch (std::exception& e) {
35454       {
35455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35456       };
35457     } catch (...) {
35458       {
35459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35460       };
35461     }
35462   }
35463   jresult = (void *)result;
35464   return jresult;
35465 }
35466
35467
35468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
35469   void * jresult ;
35470   Dali::Vector2 *arg1 = 0 ;
35471   Dali::Vector2 *arg2 = 0 ;
35472   Dali::AlphaFunction *result = 0 ;
35473
35474   arg1 = (Dali::Vector2 *)jarg1;
35475   if (!arg1) {
35476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
35477     return 0;
35478   }
35479   arg2 = (Dali::Vector2 *)jarg2;
35480   if (!arg2) {
35481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
35482     return 0;
35483   }
35484   {
35485     try {
35486       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
35487     } catch (std::out_of_range& e) {
35488       {
35489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35490       };
35491     } catch (std::exception& e) {
35492       {
35493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35494       };
35495     } catch (...) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35498       };
35499     }
35500   }
35501   jresult = (void *)result;
35502   return jresult;
35503 }
35504
35505
35506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
35507   void * jresult ;
35508   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
35509   Dali::Vector4 result;
35510
35511   arg1 = (Dali::AlphaFunction *)jarg1;
35512   {
35513     try {
35514       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
35515     } catch (std::out_of_range& e) {
35516       {
35517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35518       };
35519     } catch (std::exception& e) {
35520       {
35521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35522       };
35523     } catch (...) {
35524       {
35525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35526       };
35527     }
35528   }
35529   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35530   return jresult;
35531 }
35532
35533
35534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
35535   void * jresult ;
35536   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
35537   Dali::AlphaFunctionPrototype result;
35538
35539   arg1 = (Dali::AlphaFunction *)jarg1;
35540   {
35541     try {
35542       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
35543     } catch (std::out_of_range& e) {
35544       {
35545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35546       };
35547     } catch (std::exception& e) {
35548       {
35549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35550       };
35551     } catch (...) {
35552       {
35553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35554       };
35555     }
35556   }
35557   jresult = (void *)result;
35558   return jresult;
35559 }
35560
35561
35562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
35563   int jresult ;
35564   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
35565   Dali::AlphaFunction::BuiltinFunction result;
35566
35567   arg1 = (Dali::AlphaFunction *)jarg1;
35568   {
35569     try {
35570       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
35571     } catch (std::out_of_range& e) {
35572       {
35573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35574       };
35575     } catch (std::exception& e) {
35576       {
35577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35578       };
35579     } catch (...) {
35580       {
35581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35582       };
35583     }
35584   }
35585   jresult = (int)result;
35586   return jresult;
35587 }
35588
35589
35590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
35591   int jresult ;
35592   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
35593   Dali::AlphaFunction::Mode result;
35594
35595   arg1 = (Dali::AlphaFunction *)jarg1;
35596   {
35597     try {
35598       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
35599     } catch (std::out_of_range& e) {
35600       {
35601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35602       };
35603     } catch (std::exception& e) {
35604       {
35605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35606       };
35607     } catch (...) {
35608       {
35609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35610       };
35611     }
35612   }
35613   jresult = (int)result;
35614   return jresult;
35615 }
35616
35617
35618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
35619   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
35620
35621   arg1 = (Dali::AlphaFunction *)jarg1;
35622   {
35623     try {
35624       delete arg1;
35625     } catch (std::out_of_range& e) {
35626       {
35627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35628       };
35629     } catch (std::exception& e) {
35630       {
35631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35632       };
35633     } catch (...) {
35634       {
35635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35636       };
35637     }
35638   }
35639 }
35640
35641
35642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
35643   void * jresult ;
35644   Dali::KeyFrames result;
35645
35646   {
35647     try {
35648       result = Dali::KeyFrames::New();
35649     } catch (std::out_of_range& e) {
35650       {
35651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35652       };
35653     } catch (std::exception& e) {
35654       {
35655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35656       };
35657     } catch (...) {
35658       {
35659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35660       };
35661     }
35662   }
35663   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
35664   return jresult;
35665 }
35666
35667
35668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
35669   void * jresult ;
35670   Dali::BaseHandle arg1 ;
35671   Dali::BaseHandle *argp1 ;
35672   Dali::KeyFrames result;
35673
35674   argp1 = (Dali::BaseHandle *)jarg1;
35675   if (!argp1) {
35676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35677     return 0;
35678   }
35679   arg1 = *argp1;
35680   {
35681     try {
35682       result = Dali::KeyFrames::DownCast(arg1);
35683     } catch (std::out_of_range& e) {
35684       {
35685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35686       };
35687     } catch (std::exception& e) {
35688       {
35689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35690       };
35691     } catch (...) {
35692       {
35693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35694       };
35695     }
35696   }
35697   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
35698   return jresult;
35699 }
35700
35701
35702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
35703   void * jresult ;
35704   Dali::KeyFrames *result = 0 ;
35705
35706   {
35707     try {
35708       result = (Dali::KeyFrames *)new Dali::KeyFrames();
35709     } catch (std::out_of_range& e) {
35710       {
35711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35712       };
35713     } catch (std::exception& e) {
35714       {
35715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35716       };
35717     } catch (...) {
35718       {
35719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35720       };
35721     }
35722   }
35723   jresult = (void *)result;
35724   return jresult;
35725 }
35726
35727
35728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
35729   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
35730
35731   arg1 = (Dali::KeyFrames *)jarg1;
35732   {
35733     try {
35734       delete arg1;
35735     } catch (std::out_of_range& e) {
35736       {
35737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35738       };
35739     } catch (std::exception& e) {
35740       {
35741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35742       };
35743     } catch (...) {
35744       {
35745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35746       };
35747     }
35748   }
35749 }
35750
35751
35752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
35753   void * jresult ;
35754   Dali::KeyFrames *arg1 = 0 ;
35755   Dali::KeyFrames *result = 0 ;
35756
35757   arg1 = (Dali::KeyFrames *)jarg1;
35758   if (!arg1) {
35759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
35760     return 0;
35761   }
35762   {
35763     try {
35764       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
35765     } catch (std::out_of_range& e) {
35766       {
35767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35768       };
35769     } catch (std::exception& e) {
35770       {
35771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35772       };
35773     } catch (...) {
35774       {
35775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35776       };
35777     }
35778   }
35779   jresult = (void *)result;
35780   return jresult;
35781 }
35782
35783
35784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
35785   void * jresult ;
35786   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
35787   Dali::KeyFrames *arg2 = 0 ;
35788   Dali::KeyFrames *result = 0 ;
35789
35790   arg1 = (Dali::KeyFrames *)jarg1;
35791   arg2 = (Dali::KeyFrames *)jarg2;
35792   if (!arg2) {
35793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
35794     return 0;
35795   }
35796   {
35797     try {
35798       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
35799     } catch (std::out_of_range& e) {
35800       {
35801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35802       };
35803     } catch (std::exception& e) {
35804       {
35805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35806       };
35807     } catch (...) {
35808       {
35809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35810       };
35811     }
35812   }
35813   jresult = (void *)result;
35814   return jresult;
35815 }
35816
35817
35818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
35819   int jresult ;
35820   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
35821   Dali::Property::Type result;
35822
35823   arg1 = (Dali::KeyFrames *)jarg1;
35824   {
35825     try {
35826       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
35827     } catch (std::out_of_range& e) {
35828       {
35829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35830       };
35831     } catch (std::exception& e) {
35832       {
35833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35834       };
35835     } catch (...) {
35836       {
35837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35838       };
35839     }
35840   }
35841   jresult = (int)result;
35842   return jresult;
35843 }
35844
35845
35846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
35847   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
35848   float arg2 ;
35849   Dali::Property::Value arg3 ;
35850   Dali::Property::Value *argp3 ;
35851
35852   arg1 = (Dali::KeyFrames *)jarg1;
35853   arg2 = (float)jarg2;
35854   argp3 = (Dali::Property::Value *)jarg3;
35855   if (!argp3) {
35856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
35857     return ;
35858   }
35859   arg3 = *argp3;
35860   {
35861     try {
35862       (arg1)->Add(arg2,arg3);
35863     } catch (std::out_of_range& e) {
35864       {
35865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35866       };
35867     } catch (std::exception& e) {
35868       {
35869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35870       };
35871     } catch (...) {
35872       {
35873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35874       };
35875     }
35876   }
35877 }
35878
35879
35880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
35881   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
35882   float arg2 ;
35883   Dali::Property::Value arg3 ;
35884   Dali::AlphaFunction arg4 ;
35885   Dali::Property::Value *argp3 ;
35886   Dali::AlphaFunction *argp4 ;
35887
35888   arg1 = (Dali::KeyFrames *)jarg1;
35889   arg2 = (float)jarg2;
35890   argp3 = (Dali::Property::Value *)jarg3;
35891   if (!argp3) {
35892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
35893     return ;
35894   }
35895   arg3 = *argp3;
35896   argp4 = (Dali::AlphaFunction *)jarg4;
35897   if (!argp4) {
35898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
35899     return ;
35900   }
35901   arg4 = *argp4;
35902   {
35903     try {
35904       (arg1)->Add(arg2,arg3,arg4);
35905     } catch (std::out_of_range& e) {
35906       {
35907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35908       };
35909     } catch (std::exception& e) {
35910       {
35911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35912       };
35913     } catch (...) {
35914       {
35915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35916       };
35917     }
35918   }
35919 }
35920
35921
35922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
35923   int jresult ;
35924   int result;
35925
35926   result = (int)Dali::Path::Property::POINTS;
35927   jresult = (int)result;
35928   return jresult;
35929 }
35930
35931
35932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
35933   int jresult ;
35934   int result;
35935
35936   result = (int)Dali::Path::Property::CONTROL_POINTS;
35937   jresult = (int)result;
35938   return jresult;
35939 }
35940
35941
35942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
35943   void * jresult ;
35944   Dali::Path::Property *result = 0 ;
35945
35946   {
35947     try {
35948       result = (Dali::Path::Property *)new Dali::Path::Property();
35949     } catch (std::out_of_range& e) {
35950       {
35951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35952       };
35953     } catch (std::exception& e) {
35954       {
35955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35956       };
35957     } catch (...) {
35958       {
35959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35960       };
35961     }
35962   }
35963   jresult = (void *)result;
35964   return jresult;
35965 }
35966
35967
35968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
35969   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
35970
35971   arg1 = (Dali::Path::Property *)jarg1;
35972   {
35973     try {
35974       delete arg1;
35975     } catch (std::out_of_range& e) {
35976       {
35977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35978       };
35979     } catch (std::exception& e) {
35980       {
35981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35982       };
35983     } catch (...) {
35984       {
35985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35986       };
35987     }
35988   }
35989 }
35990
35991
35992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
35993   void * jresult ;
35994   Dali::Path result;
35995
35996   {
35997     try {
35998       result = Dali::Path::New();
35999     } catch (std::out_of_range& e) {
36000       {
36001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36002       };
36003     } catch (std::exception& e) {
36004       {
36005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36006       };
36007     } catch (...) {
36008       {
36009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36010       };
36011     }
36012   }
36013   jresult = new Dali::Path((const Dali::Path &)result);
36014   return jresult;
36015 }
36016
36017
36018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
36019   void * jresult ;
36020   Dali::BaseHandle arg1 ;
36021   Dali::BaseHandle *argp1 ;
36022   Dali::Path result;
36023
36024   argp1 = (Dali::BaseHandle *)jarg1;
36025   if (!argp1) {
36026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36027     return 0;
36028   }
36029   arg1 = *argp1;
36030   {
36031     try {
36032       result = Dali::Path::DownCast(arg1);
36033     } catch (std::out_of_range& e) {
36034       {
36035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36036       };
36037     } catch (std::exception& e) {
36038       {
36039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36040       };
36041     } catch (...) {
36042       {
36043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36044       };
36045     }
36046   }
36047   jresult = new Dali::Path((const Dali::Path &)result);
36048   return jresult;
36049 }
36050
36051
36052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
36053   void * jresult ;
36054   Dali::Path *result = 0 ;
36055
36056   {
36057     try {
36058       result = (Dali::Path *)new Dali::Path();
36059     } catch (std::out_of_range& e) {
36060       {
36061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36062       };
36063     } catch (std::exception& e) {
36064       {
36065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36066       };
36067     } catch (...) {
36068       {
36069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36070       };
36071     }
36072   }
36073   jresult = (void *)result;
36074   return jresult;
36075 }
36076
36077
36078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
36079   Dali::Path *arg1 = (Dali::Path *) 0 ;
36080
36081   arg1 = (Dali::Path *)jarg1;
36082   {
36083     try {
36084       delete arg1;
36085     } catch (std::out_of_range& e) {
36086       {
36087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36088       };
36089     } catch (std::exception& e) {
36090       {
36091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36092       };
36093     } catch (...) {
36094       {
36095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36096       };
36097     }
36098   }
36099 }
36100
36101
36102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
36103   void * jresult ;
36104   Dali::Path *arg1 = 0 ;
36105   Dali::Path *result = 0 ;
36106
36107   arg1 = (Dali::Path *)jarg1;
36108   if (!arg1) {
36109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
36110     return 0;
36111   }
36112   {
36113     try {
36114       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
36115     } catch (std::out_of_range& e) {
36116       {
36117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36118       };
36119     } catch (std::exception& e) {
36120       {
36121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36122       };
36123     } catch (...) {
36124       {
36125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36126       };
36127     }
36128   }
36129   jresult = (void *)result;
36130   return jresult;
36131 }
36132
36133
36134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
36135   void * jresult ;
36136   Dali::Path *arg1 = (Dali::Path *) 0 ;
36137   Dali::Path *arg2 = 0 ;
36138   Dali::Path *result = 0 ;
36139
36140   arg1 = (Dali::Path *)jarg1;
36141   arg2 = (Dali::Path *)jarg2;
36142   if (!arg2) {
36143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
36144     return 0;
36145   }
36146   {
36147     try {
36148       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
36149     } catch (std::out_of_range& e) {
36150       {
36151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36152       };
36153     } catch (std::exception& e) {
36154       {
36155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36156       };
36157     } catch (...) {
36158       {
36159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36160       };
36161     }
36162   }
36163   jresult = (void *)result;
36164   return jresult;
36165 }
36166
36167
36168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
36169   Dali::Path *arg1 = (Dali::Path *) 0 ;
36170   Dali::Vector3 *arg2 = 0 ;
36171
36172   arg1 = (Dali::Path *)jarg1;
36173   arg2 = (Dali::Vector3 *)jarg2;
36174   if (!arg2) {
36175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36176     return ;
36177   }
36178   {
36179     try {
36180       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
36181     } catch (std::out_of_range& e) {
36182       {
36183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36184       };
36185     } catch (std::exception& e) {
36186       {
36187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36188       };
36189     } catch (...) {
36190       {
36191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36192       };
36193     }
36194   }
36195 }
36196
36197
36198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
36199   Dali::Path *arg1 = (Dali::Path *) 0 ;
36200   Dali::Vector3 *arg2 = 0 ;
36201
36202   arg1 = (Dali::Path *)jarg1;
36203   arg2 = (Dali::Vector3 *)jarg2;
36204   if (!arg2) {
36205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36206     return ;
36207   }
36208   {
36209     try {
36210       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
36211     } catch (std::out_of_range& e) {
36212       {
36213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36214       };
36215     } catch (std::exception& e) {
36216       {
36217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36218       };
36219     } catch (...) {
36220       {
36221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36222       };
36223     }
36224   }
36225 }
36226
36227
36228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
36229   Dali::Path *arg1 = (Dali::Path *) 0 ;
36230   float arg2 ;
36231
36232   arg1 = (Dali::Path *)jarg1;
36233   arg2 = (float)jarg2;
36234   {
36235     try {
36236       (arg1)->GenerateControlPoints(arg2);
36237     } catch (std::out_of_range& e) {
36238       {
36239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36240       };
36241     } catch (std::exception& e) {
36242       {
36243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36244       };
36245     } catch (...) {
36246       {
36247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36248       };
36249     }
36250   }
36251 }
36252
36253
36254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
36255   Dali::Path *arg1 = (Dali::Path *) 0 ;
36256   float arg2 ;
36257   Dali::Vector3 *arg3 = 0 ;
36258   Dali::Vector3 *arg4 = 0 ;
36259
36260   arg1 = (Dali::Path *)jarg1;
36261   arg2 = (float)jarg2;
36262   arg3 = (Dali::Vector3 *)jarg3;
36263   if (!arg3) {
36264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
36265     return ;
36266   }
36267   arg4 = (Dali::Vector3 *)jarg4;
36268   if (!arg4) {
36269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
36270     return ;
36271   }
36272   {
36273     try {
36274       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
36275     } catch (std::out_of_range& e) {
36276       {
36277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36278       };
36279     } catch (std::exception& e) {
36280       {
36281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36282       };
36283     } catch (...) {
36284       {
36285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36286       };
36287     }
36288   }
36289 }
36290
36291
36292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
36293   void * jresult ;
36294   Dali::Path *arg1 = (Dali::Path *) 0 ;
36295   size_t arg2 ;
36296   Dali::Vector3 *result = 0 ;
36297
36298   arg1 = (Dali::Path *)jarg1;
36299   arg2 = (size_t)jarg2;
36300   {
36301     try {
36302       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
36303     } catch (std::out_of_range& e) {
36304       {
36305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36306       };
36307     } catch (std::exception& e) {
36308       {
36309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36310       };
36311     } catch (...) {
36312       {
36313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36314       };
36315     }
36316   }
36317   jresult = (void *)result;
36318   return jresult;
36319 }
36320
36321
36322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
36323   void * jresult ;
36324   Dali::Path *arg1 = (Dali::Path *) 0 ;
36325   size_t arg2 ;
36326   Dali::Vector3 *result = 0 ;
36327
36328   arg1 = (Dali::Path *)jarg1;
36329   arg2 = (size_t)jarg2;
36330   {
36331     try {
36332       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
36333     } catch (std::out_of_range& e) {
36334       {
36335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36336       };
36337     } catch (std::exception& e) {
36338       {
36339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36340       };
36341     } catch (...) {
36342       {
36343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36344       };
36345     }
36346   }
36347   jresult = (void *)result;
36348   return jresult;
36349 }
36350
36351
36352 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
36353   unsigned long jresult ;
36354   Dali::Path *arg1 = (Dali::Path *) 0 ;
36355   size_t result;
36356
36357   arg1 = (Dali::Path *)jarg1;
36358   {
36359     try {
36360       result = ((Dali::Path const *)arg1)->GetPointCount();
36361     } catch (std::out_of_range& e) {
36362       {
36363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36364       };
36365     } catch (std::exception& e) {
36366       {
36367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36368       };
36369     } catch (...) {
36370       {
36371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36372       };
36373     }
36374   }
36375   jresult = (unsigned long)result;
36376   return jresult;
36377 }
36378
36379
36380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
36381   void * jresult ;
36382   float arg1 ;
36383   Dali::TimePeriod *result = 0 ;
36384
36385   arg1 = (float)jarg1;
36386   {
36387     try {
36388       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
36389     } catch (std::out_of_range& e) {
36390       {
36391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (std::exception& e) {
36394       {
36395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36396       };
36397     } catch (...) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36400       };
36401     }
36402   }
36403   jresult = (void *)result;
36404   return jresult;
36405 }
36406
36407
36408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
36409   void * jresult ;
36410   float arg1 ;
36411   float arg2 ;
36412   Dali::TimePeriod *result = 0 ;
36413
36414   arg1 = (float)jarg1;
36415   arg2 = (float)jarg2;
36416   {
36417     try {
36418       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
36419     } catch (std::out_of_range& e) {
36420       {
36421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36422       };
36423     } catch (std::exception& e) {
36424       {
36425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36426       };
36427     } catch (...) {
36428       {
36429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36430       };
36431     }
36432   }
36433   jresult = (void *)result;
36434   return jresult;
36435 }
36436
36437
36438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
36439   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
36440
36441   arg1 = (Dali::TimePeriod *)jarg1;
36442   {
36443     try {
36444       delete arg1;
36445     } catch (std::out_of_range& e) {
36446       {
36447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36448       };
36449     } catch (std::exception& e) {
36450       {
36451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36452       };
36453     } catch (...) {
36454       {
36455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36456       };
36457     }
36458   }
36459 }
36460
36461
36462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
36463   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
36464   float arg2 ;
36465
36466   arg1 = (Dali::TimePeriod *)jarg1;
36467   arg2 = (float)jarg2;
36468   if (arg1) (arg1)->delaySeconds = arg2;
36469 }
36470
36471
36472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
36473   float jresult ;
36474   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
36475   float result;
36476
36477   arg1 = (Dali::TimePeriod *)jarg1;
36478   result = (float) ((arg1)->delaySeconds);
36479   jresult = result;
36480   return jresult;
36481 }
36482
36483
36484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
36485   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
36486   float arg2 ;
36487
36488   arg1 = (Dali::TimePeriod *)jarg1;
36489   arg2 = (float)jarg2;
36490   if (arg1) (arg1)->durationSeconds = arg2;
36491 }
36492
36493
36494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
36495   float jresult ;
36496   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
36497   float result;
36498
36499   arg1 = (Dali::TimePeriod *)jarg1;
36500   result = (float) ((arg1)->durationSeconds);
36501   jresult = result;
36502   return jresult;
36503 }
36504
36505
36506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
36507   void * jresult ;
36508   Dali::Animation *result = 0 ;
36509
36510   {
36511     try {
36512       result = (Dali::Animation *)new Dali::Animation();
36513     } catch (std::out_of_range& e) {
36514       {
36515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36516       };
36517     } catch (std::exception& e) {
36518       {
36519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36520       };
36521     } catch (...) {
36522       {
36523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36524       };
36525     }
36526   }
36527   jresult = (void *)result;
36528   return jresult;
36529 }
36530
36531
36532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
36533   void * jresult ;
36534   float arg1 ;
36535   Dali::Animation result;
36536
36537   arg1 = (float)jarg1;
36538   {
36539     try {
36540       result = Dali::Animation::New(arg1);
36541     } catch (std::out_of_range& e) {
36542       {
36543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36544       };
36545     } catch (std::exception& e) {
36546       {
36547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36548       };
36549     } catch (...) {
36550       {
36551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36552       };
36553     }
36554   }
36555   jresult = new Dali::Animation((const Dali::Animation &)result);
36556   return jresult;
36557 }
36558
36559
36560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
36561   void * jresult ;
36562   Dali::BaseHandle arg1 ;
36563   Dali::BaseHandle *argp1 ;
36564   Dali::Animation result;
36565
36566   argp1 = (Dali::BaseHandle *)jarg1;
36567   if (!argp1) {
36568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36569     return 0;
36570   }
36571   arg1 = *argp1;
36572   {
36573     try {
36574       result = Dali::Animation::DownCast(arg1);
36575     } catch (std::out_of_range& e) {
36576       {
36577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36578       };
36579     } catch (std::exception& e) {
36580       {
36581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36582       };
36583     } catch (...) {
36584       {
36585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36586       };
36587     }
36588   }
36589   jresult = new Dali::Animation((const Dali::Animation &)result);
36590   return jresult;
36591 }
36592
36593
36594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
36595   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36596
36597   arg1 = (Dali::Animation *)jarg1;
36598   {
36599     try {
36600       delete arg1;
36601     } catch (std::out_of_range& e) {
36602       {
36603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36604       };
36605     } catch (std::exception& e) {
36606       {
36607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36608       };
36609     } catch (...) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36612       };
36613     }
36614   }
36615 }
36616
36617
36618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
36619   void * jresult ;
36620   Dali::Animation *arg1 = 0 ;
36621   Dali::Animation *result = 0 ;
36622
36623   arg1 = (Dali::Animation *)jarg1;
36624   if (!arg1) {
36625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
36626     return 0;
36627   }
36628   {
36629     try {
36630       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
36631     } catch (std::out_of_range& e) {
36632       {
36633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36634       };
36635     } catch (std::exception& e) {
36636       {
36637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36638       };
36639     } catch (...) {
36640       {
36641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36642       };
36643     }
36644   }
36645   jresult = (void *)result;
36646   return jresult;
36647 }
36648
36649
36650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
36651   void * jresult ;
36652   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36653   Dali::Animation *arg2 = 0 ;
36654   Dali::Animation *result = 0 ;
36655
36656   arg1 = (Dali::Animation *)jarg1;
36657   arg2 = (Dali::Animation *)jarg2;
36658   if (!arg2) {
36659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
36660     return 0;
36661   }
36662   {
36663     try {
36664       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
36665     } catch (std::out_of_range& e) {
36666       {
36667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36668       };
36669     } catch (std::exception& e) {
36670       {
36671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36672       };
36673     } catch (...) {
36674       {
36675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36676       };
36677     }
36678   }
36679   jresult = (void *)result;
36680   return jresult;
36681 }
36682
36683
36684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
36685   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36686   float arg2 ;
36687
36688   arg1 = (Dali::Animation *)jarg1;
36689   arg2 = (float)jarg2;
36690   {
36691     try {
36692       (arg1)->SetDuration(arg2);
36693     } catch (std::out_of_range& e) {
36694       {
36695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36696       };
36697     } catch (std::exception& e) {
36698       {
36699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36700       };
36701     } catch (...) {
36702       {
36703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36704       };
36705     }
36706   }
36707 }
36708
36709
36710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
36711   float jresult ;
36712   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36713   float result;
36714
36715   arg1 = (Dali::Animation *)jarg1;
36716   {
36717     try {
36718       result = (float)((Dali::Animation const *)arg1)->GetDuration();
36719     } catch (std::out_of_range& e) {
36720       {
36721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36722       };
36723     } catch (std::exception& e) {
36724       {
36725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36726       };
36727     } catch (...) {
36728       {
36729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36730       };
36731     }
36732   }
36733   jresult = result;
36734   return jresult;
36735 }
36736
36737
36738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
36739   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36740   bool arg2 ;
36741
36742   arg1 = (Dali::Animation *)jarg1;
36743   arg2 = jarg2 ? true : false;
36744   {
36745     try {
36746       (arg1)->SetLooping(arg2);
36747     } catch (std::out_of_range& e) {
36748       {
36749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36750       };
36751     } catch (std::exception& e) {
36752       {
36753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36754       };
36755     } catch (...) {
36756       {
36757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36758       };
36759     }
36760   }
36761 }
36762
36763
36764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
36765   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36766   int arg2 ;
36767
36768   arg1 = (Dali::Animation *)jarg1;
36769   arg2 = (int)jarg2;
36770   {
36771     try {
36772       (arg1)->SetLoopCount(arg2);
36773     } catch (std::out_of_range& e) {
36774       {
36775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36776       };
36777     } catch (std::exception& e) {
36778       {
36779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36780       };
36781     } catch (...) {
36782       {
36783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36784       };
36785     }
36786   }
36787 }
36788
36789
36790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
36791   int jresult ;
36792   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36793   int result;
36794
36795   arg1 = (Dali::Animation *)jarg1;
36796   {
36797     try {
36798       result = (int)(arg1)->GetLoopCount();
36799     } catch (std::out_of_range& e) {
36800       {
36801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36802       };
36803     } catch (std::exception& e) {
36804       {
36805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36806       };
36807     } catch (...) {
36808       {
36809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36810       };
36811     }
36812   }
36813   jresult = result;
36814   return jresult;
36815 }
36816
36817
36818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
36819   int jresult ;
36820   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36821   int result;
36822
36823   arg1 = (Dali::Animation *)jarg1;
36824   {
36825     try {
36826       result = (int)(arg1)->GetCurrentLoop();
36827     } catch (std::out_of_range& e) {
36828       {
36829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36830       };
36831     } catch (std::exception& e) {
36832       {
36833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36834       };
36835     } catch (...) {
36836       {
36837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36838       };
36839     }
36840   }
36841   jresult = result;
36842   return jresult;
36843 }
36844
36845
36846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
36847   unsigned int jresult ;
36848   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36849   bool result;
36850
36851   arg1 = (Dali::Animation *)jarg1;
36852   {
36853     try {
36854       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
36855     } catch (std::out_of_range& e) {
36856       {
36857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36858       };
36859     } catch (std::exception& e) {
36860       {
36861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36862       };
36863     } catch (...) {
36864       {
36865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36866       };
36867     }
36868   }
36869   jresult = result;
36870   return jresult;
36871 }
36872
36873
36874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
36875   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36876   Dali::Animation::EndAction arg2 ;
36877
36878   arg1 = (Dali::Animation *)jarg1;
36879   arg2 = (Dali::Animation::EndAction)jarg2;
36880   {
36881     try {
36882       (arg1)->SetEndAction(arg2);
36883     } catch (std::out_of_range& e) {
36884       {
36885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36886       };
36887     } catch (std::exception& e) {
36888       {
36889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36890       };
36891     } catch (...) {
36892       {
36893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36894       };
36895     }
36896   }
36897 }
36898
36899
36900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
36901   int jresult ;
36902   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36903   Dali::Animation::EndAction result;
36904
36905   arg1 = (Dali::Animation *)jarg1;
36906   {
36907     try {
36908       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
36909     } catch (std::out_of_range& e) {
36910       {
36911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36912       };
36913     } catch (std::exception& e) {
36914       {
36915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36916       };
36917     } catch (...) {
36918       {
36919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36920       };
36921     }
36922   }
36923   jresult = (int)result;
36924   return jresult;
36925 }
36926
36927
36928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
36929   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36930   Dali::Animation::EndAction arg2 ;
36931
36932   arg1 = (Dali::Animation *)jarg1;
36933   arg2 = (Dali::Animation::EndAction)jarg2;
36934   {
36935     try {
36936       (arg1)->SetDisconnectAction(arg2);
36937     } catch (std::out_of_range& e) {
36938       {
36939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36940       };
36941     } catch (std::exception& e) {
36942       {
36943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36944       };
36945     } catch (...) {
36946       {
36947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36948       };
36949     }
36950   }
36951 }
36952
36953
36954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
36955   int jresult ;
36956   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36957   Dali::Animation::EndAction result;
36958
36959   arg1 = (Dali::Animation *)jarg1;
36960   {
36961     try {
36962       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
36963     } catch (std::out_of_range& e) {
36964       {
36965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36966       };
36967     } catch (std::exception& e) {
36968       {
36969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36970       };
36971     } catch (...) {
36972       {
36973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36974       };
36975     }
36976   }
36977   jresult = (int)result;
36978   return jresult;
36979 }
36980
36981
36982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
36983   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
36984   Dali::AlphaFunction arg2 ;
36985   Dali::AlphaFunction *argp2 ;
36986
36987   arg1 = (Dali::Animation *)jarg1;
36988   argp2 = (Dali::AlphaFunction *)jarg2;
36989   if (!argp2) {
36990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
36991     return ;
36992   }
36993   arg2 = *argp2;
36994   {
36995     try {
36996       (arg1)->SetDefaultAlphaFunction(arg2);
36997     } catch (std::out_of_range& e) {
36998       {
36999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37000       };
37001     } catch (std::exception& e) {
37002       {
37003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37004       };
37005     } catch (...) {
37006       {
37007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37008       };
37009     }
37010   }
37011 }
37012
37013
37014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
37015   void * jresult ;
37016   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37017   Dali::AlphaFunction result;
37018
37019   arg1 = (Dali::Animation *)jarg1;
37020   {
37021     try {
37022       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
37023     } catch (std::out_of_range& e) {
37024       {
37025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37026       };
37027     } catch (std::exception& e) {
37028       {
37029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37030       };
37031     } catch (...) {
37032       {
37033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37034       };
37035     }
37036   }
37037   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
37038   return jresult;
37039 }
37040
37041
37042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
37043   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37044   float arg2 ;
37045
37046   arg1 = (Dali::Animation *)jarg1;
37047   arg2 = (float)jarg2;
37048   {
37049     try {
37050       (arg1)->SetCurrentProgress(arg2);
37051     } catch (std::out_of_range& e) {
37052       {
37053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37054       };
37055     } catch (std::exception& e) {
37056       {
37057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37058       };
37059     } catch (...) {
37060       {
37061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37062       };
37063     }
37064   }
37065 }
37066
37067
37068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
37069   float jresult ;
37070   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37071   float result;
37072
37073   arg1 = (Dali::Animation *)jarg1;
37074   {
37075     try {
37076       result = (float)(arg1)->GetCurrentProgress();
37077     } catch (std::out_of_range& e) {
37078       {
37079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37080       };
37081     } catch (std::exception& e) {
37082       {
37083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37084       };
37085     } catch (...) {
37086       {
37087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37088       };
37089     }
37090   }
37091   jresult = result;
37092   return jresult;
37093 }
37094
37095
37096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
37097   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37098   float arg2 ;
37099
37100   arg1 = (Dali::Animation *)jarg1;
37101   arg2 = (float)jarg2;
37102   {
37103     try {
37104       (arg1)->SetSpeedFactor(arg2);
37105     } catch (std::out_of_range& e) {
37106       {
37107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37108       };
37109     } catch (std::exception& e) {
37110       {
37111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37112       };
37113     } catch (...) {
37114       {
37115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37116       };
37117     }
37118   }
37119 }
37120
37121
37122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
37123   float jresult ;
37124   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37125   float result;
37126
37127   arg1 = (Dali::Animation *)jarg1;
37128   {
37129     try {
37130       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
37131     } catch (std::out_of_range& e) {
37132       {
37133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37134       };
37135     } catch (std::exception& e) {
37136       {
37137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37138       };
37139     } catch (...) {
37140       {
37141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37142       };
37143     }
37144   }
37145   jresult = result;
37146   return jresult;
37147 }
37148
37149
37150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
37151   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37152   Dali::Vector2 *arg2 = 0 ;
37153
37154   arg1 = (Dali::Animation *)jarg1;
37155   arg2 = (Dali::Vector2 *)jarg2;
37156   if (!arg2) {
37157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37158     return ;
37159   }
37160   {
37161     try {
37162       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
37163     } catch (std::out_of_range& e) {
37164       {
37165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37166       };
37167     } catch (std::exception& e) {
37168       {
37169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37170       };
37171     } catch (...) {
37172       {
37173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37174       };
37175     }
37176   }
37177 }
37178
37179
37180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
37181   void * jresult ;
37182   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37183   Dali::Vector2 result;
37184
37185   arg1 = (Dali::Animation *)jarg1;
37186   {
37187     try {
37188       result = ((Dali::Animation const *)arg1)->GetPlayRange();
37189     } catch (std::out_of_range& e) {
37190       {
37191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37192       };
37193     } catch (std::exception& e) {
37194       {
37195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37196       };
37197     } catch (...) {
37198       {
37199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37200       };
37201     }
37202   }
37203   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
37204   return jresult;
37205 }
37206
37207
37208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
37209   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37210
37211   arg1 = (Dali::Animation *)jarg1;
37212   {
37213     try {
37214       (arg1)->Play();
37215     } catch (std::out_of_range& e) {
37216       {
37217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37218       };
37219     } catch (std::exception& e) {
37220       {
37221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37222       };
37223     } catch (...) {
37224       {
37225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37226       };
37227     }
37228   }
37229 }
37230
37231
37232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
37233   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37234   float arg2 ;
37235
37236   arg1 = (Dali::Animation *)jarg1;
37237   arg2 = (float)jarg2;
37238   {
37239     try {
37240       (arg1)->PlayFrom(arg2);
37241     } catch (std::out_of_range& e) {
37242       {
37243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37244       };
37245     } catch (std::exception& e) {
37246       {
37247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37248       };
37249     } catch (...) {
37250       {
37251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37252       };
37253     }
37254   }
37255 }
37256
37257
37258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
37259   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37260
37261   arg1 = (Dali::Animation *)jarg1;
37262   {
37263     try {
37264       (arg1)->Pause();
37265     } catch (std::out_of_range& e) {
37266       {
37267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37268       };
37269     } catch (std::exception& e) {
37270       {
37271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37272       };
37273     } catch (...) {
37274       {
37275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37276       };
37277     }
37278   }
37279 }
37280
37281
37282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
37283   int jresult ;
37284   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37285   Dali::Animation::State result;
37286
37287   arg1 = (Dali::Animation *)jarg1;
37288   {
37289     try {
37290       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
37291     } catch (std::out_of_range& e) {
37292       {
37293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37294       };
37295     } catch (std::exception& e) {
37296       {
37297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37298       };
37299     } catch (...) {
37300       {
37301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37302       };
37303     }
37304   }
37305   jresult = (int)result;
37306   return jresult;
37307 }
37308
37309
37310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
37311   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37312
37313   arg1 = (Dali::Animation *)jarg1;
37314   {
37315     try {
37316       (arg1)->Stop();
37317     } catch (std::out_of_range& e) {
37318       {
37319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37320       };
37321     } catch (std::exception& e) {
37322       {
37323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37324       };
37325     } catch (...) {
37326       {
37327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37328       };
37329     }
37330   }
37331 }
37332
37333
37334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
37335   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37336
37337   arg1 = (Dali::Animation *)jarg1;
37338   {
37339     try {
37340       (arg1)->Clear();
37341     } catch (std::out_of_range& e) {
37342       {
37343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37344       };
37345     } catch (std::exception& e) {
37346       {
37347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37348       };
37349     } catch (...) {
37350       {
37351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37352       };
37353     }
37354   }
37355 }
37356
37357
37358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
37359   void * jresult ;
37360   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37361   Dali::Animation::AnimationSignalType *result = 0 ;
37362
37363   arg1 = (Dali::Animation *)jarg1;
37364   {
37365     try {
37366       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
37367     } catch (std::out_of_range& e) {
37368       {
37369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37370       };
37371     } catch (std::exception& e) {
37372       {
37373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37374       };
37375     } catch (...) {
37376       {
37377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37378       };
37379     }
37380   }
37381   jresult = (void *)result;
37382   return jresult;
37383 }
37384
37385
37386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
37387   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37388   SwigValueWrapper< Dali::Property > arg2 ;
37389   Dali::Property::Value arg3 ;
37390   Dali::Property *argp2 ;
37391   Dali::Property::Value *argp3 ;
37392
37393   arg1 = (Dali::Animation *)jarg1;
37394   argp2 = (Dali::Property *)jarg2;
37395   if (!argp2) {
37396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37397     return ;
37398   }
37399   arg2 = *argp2;
37400   argp3 = (Dali::Property::Value *)jarg3;
37401   if (!argp3) {
37402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37403     return ;
37404   }
37405   arg3 = *argp3;
37406   {
37407     try {
37408       (arg1)->AnimateBy(arg2,arg3);
37409     } catch (std::out_of_range& e) {
37410       {
37411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37412       };
37413     } catch (std::exception& e) {
37414       {
37415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37416       };
37417     } catch (...) {
37418       {
37419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37420       };
37421     }
37422   }
37423 }
37424
37425
37426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
37427   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37428   SwigValueWrapper< Dali::Property > arg2 ;
37429   Dali::Property::Value arg3 ;
37430   Dali::AlphaFunction arg4 ;
37431   Dali::Property *argp2 ;
37432   Dali::Property::Value *argp3 ;
37433   Dali::AlphaFunction *argp4 ;
37434
37435   arg1 = (Dali::Animation *)jarg1;
37436   argp2 = (Dali::Property *)jarg2;
37437   if (!argp2) {
37438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37439     return ;
37440   }
37441   arg2 = *argp2;
37442   argp3 = (Dali::Property::Value *)jarg3;
37443   if (!argp3) {
37444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37445     return ;
37446   }
37447   arg3 = *argp3;
37448   argp4 = (Dali::AlphaFunction *)jarg4;
37449   if (!argp4) {
37450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37451     return ;
37452   }
37453   arg4 = *argp4;
37454   {
37455     try {
37456       (arg1)->AnimateBy(arg2,arg3,arg4);
37457     } catch (std::out_of_range& e) {
37458       {
37459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37460       };
37461     } catch (std::exception& e) {
37462       {
37463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37464       };
37465     } catch (...) {
37466       {
37467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37468       };
37469     }
37470   }
37471 }
37472
37473
37474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
37475   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37476   SwigValueWrapper< Dali::Property > arg2 ;
37477   Dali::Property::Value arg3 ;
37478   SwigValueWrapper< Dali::TimePeriod > arg4 ;
37479   Dali::Property *argp2 ;
37480   Dali::Property::Value *argp3 ;
37481   Dali::TimePeriod *argp4 ;
37482
37483   arg1 = (Dali::Animation *)jarg1;
37484   argp2 = (Dali::Property *)jarg2;
37485   if (!argp2) {
37486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37487     return ;
37488   }
37489   arg2 = *argp2;
37490   argp3 = (Dali::Property::Value *)jarg3;
37491   if (!argp3) {
37492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37493     return ;
37494   }
37495   arg3 = *argp3;
37496   argp4 = (Dali::TimePeriod *)jarg4;
37497   if (!argp4) {
37498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
37499     return ;
37500   }
37501   arg4 = *argp4;
37502   {
37503     try {
37504       (arg1)->AnimateBy(arg2,arg3,arg4);
37505     } catch (std::out_of_range& e) {
37506       {
37507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37508       };
37509     } catch (std::exception& e) {
37510       {
37511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37512       };
37513     } catch (...) {
37514       {
37515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37516       };
37517     }
37518   }
37519 }
37520
37521
37522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
37523   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37524   SwigValueWrapper< Dali::Property > arg2 ;
37525   Dali::Property::Value arg3 ;
37526   Dali::AlphaFunction arg4 ;
37527   SwigValueWrapper< Dali::TimePeriod > arg5 ;
37528   Dali::Property *argp2 ;
37529   Dali::Property::Value *argp3 ;
37530   Dali::AlphaFunction *argp4 ;
37531   Dali::TimePeriod *argp5 ;
37532
37533   arg1 = (Dali::Animation *)jarg1;
37534   argp2 = (Dali::Property *)jarg2;
37535   if (!argp2) {
37536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37537     return ;
37538   }
37539   arg2 = *argp2;
37540   argp3 = (Dali::Property::Value *)jarg3;
37541   if (!argp3) {
37542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37543     return ;
37544   }
37545   arg3 = *argp3;
37546   argp4 = (Dali::AlphaFunction *)jarg4;
37547   if (!argp4) {
37548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37549     return ;
37550   }
37551   arg4 = *argp4;
37552   argp5 = (Dali::TimePeriod *)jarg5;
37553   if (!argp5) {
37554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
37555     return ;
37556   }
37557   arg5 = *argp5;
37558   {
37559     try {
37560       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
37561     } catch (std::out_of_range& e) {
37562       {
37563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37564       };
37565     } catch (std::exception& e) {
37566       {
37567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37568       };
37569     } catch (...) {
37570       {
37571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37572       };
37573     }
37574   }
37575 }
37576
37577
37578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
37579   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37580   SwigValueWrapper< Dali::Property > arg2 ;
37581   Dali::Property::Value arg3 ;
37582   Dali::Property *argp2 ;
37583   Dali::Property::Value *argp3 ;
37584
37585   arg1 = (Dali::Animation *)jarg1;
37586   argp2 = (Dali::Property *)jarg2;
37587   if (!argp2) {
37588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37589     return ;
37590   }
37591   arg2 = *argp2;
37592   argp3 = (Dali::Property::Value *)jarg3;
37593   if (!argp3) {
37594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37595     return ;
37596   }
37597   arg3 = *argp3;
37598   {
37599     try {
37600       (arg1)->AnimateTo(arg2,arg3);
37601     } catch (std::out_of_range& e) {
37602       {
37603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37604       };
37605     } catch (std::exception& e) {
37606       {
37607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37608       };
37609     } catch (...) {
37610       {
37611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37612       };
37613     }
37614   }
37615 }
37616
37617
37618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
37619   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37620   SwigValueWrapper< Dali::Property > arg2 ;
37621   Dali::Property::Value arg3 ;
37622   Dali::AlphaFunction arg4 ;
37623   Dali::Property *argp2 ;
37624   Dali::Property::Value *argp3 ;
37625   Dali::AlphaFunction *argp4 ;
37626
37627   arg1 = (Dali::Animation *)jarg1;
37628   argp2 = (Dali::Property *)jarg2;
37629   if (!argp2) {
37630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37631     return ;
37632   }
37633   arg2 = *argp2;
37634   argp3 = (Dali::Property::Value *)jarg3;
37635   if (!argp3) {
37636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37637     return ;
37638   }
37639   arg3 = *argp3;
37640   argp4 = (Dali::AlphaFunction *)jarg4;
37641   if (!argp4) {
37642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37643     return ;
37644   }
37645   arg4 = *argp4;
37646   {
37647     try {
37648       (arg1)->AnimateTo(arg2,arg3,arg4);
37649     } catch (std::out_of_range& e) {
37650       {
37651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37652       };
37653     } catch (std::exception& e) {
37654       {
37655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37656       };
37657     } catch (...) {
37658       {
37659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37660       };
37661     }
37662   }
37663 }
37664
37665
37666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
37667   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37668   SwigValueWrapper< Dali::Property > arg2 ;
37669   Dali::Property::Value arg3 ;
37670   SwigValueWrapper< Dali::TimePeriod > arg4 ;
37671   Dali::Property *argp2 ;
37672   Dali::Property::Value *argp3 ;
37673   Dali::TimePeriod *argp4 ;
37674
37675   arg1 = (Dali::Animation *)jarg1;
37676   argp2 = (Dali::Property *)jarg2;
37677   if (!argp2) {
37678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37679     return ;
37680   }
37681   arg2 = *argp2;
37682   argp3 = (Dali::Property::Value *)jarg3;
37683   if (!argp3) {
37684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37685     return ;
37686   }
37687   arg3 = *argp3;
37688   argp4 = (Dali::TimePeriod *)jarg4;
37689   if (!argp4) {
37690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
37691     return ;
37692   }
37693   arg4 = *argp4;
37694   {
37695     try {
37696       (arg1)->AnimateTo(arg2,arg3,arg4);
37697     } catch (std::out_of_range& e) {
37698       {
37699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37700       };
37701     } catch (std::exception& e) {
37702       {
37703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37704       };
37705     } catch (...) {
37706       {
37707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37708       };
37709     }
37710   }
37711 }
37712
37713
37714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
37715   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37716   SwigValueWrapper< Dali::Property > arg2 ;
37717   Dali::Property::Value arg3 ;
37718   Dali::AlphaFunction arg4 ;
37719   SwigValueWrapper< Dali::TimePeriod > arg5 ;
37720   Dali::Property *argp2 ;
37721   Dali::Property::Value *argp3 ;
37722   Dali::AlphaFunction *argp4 ;
37723   Dali::TimePeriod *argp5 ;
37724
37725   arg1 = (Dali::Animation *)jarg1;
37726   argp2 = (Dali::Property *)jarg2;
37727   if (!argp2) {
37728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37729     return ;
37730   }
37731   arg2 = *argp2;
37732   argp3 = (Dali::Property::Value *)jarg3;
37733   if (!argp3) {
37734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37735     return ;
37736   }
37737   arg3 = *argp3;
37738   argp4 = (Dali::AlphaFunction *)jarg4;
37739   if (!argp4) {
37740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37741     return ;
37742   }
37743   arg4 = *argp4;
37744   argp5 = (Dali::TimePeriod *)jarg5;
37745   if (!argp5) {
37746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
37747     return ;
37748   }
37749   arg5 = *argp5;
37750   {
37751     try {
37752       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
37753     } catch (std::out_of_range& e) {
37754       {
37755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37756       };
37757     } catch (std::exception& e) {
37758       {
37759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37760       };
37761     } catch (...) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37764       };
37765     }
37766   }
37767 }
37768
37769
37770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
37771   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37772   SwigValueWrapper< Dali::Property > arg2 ;
37773   Dali::KeyFrames *arg3 = 0 ;
37774   Dali::Property *argp2 ;
37775
37776   arg1 = (Dali::Animation *)jarg1;
37777   argp2 = (Dali::Property *)jarg2;
37778   if (!argp2) {
37779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37780     return ;
37781   }
37782   arg2 = *argp2;
37783   arg3 = (Dali::KeyFrames *)jarg3;
37784   if (!arg3) {
37785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
37786     return ;
37787   }
37788   {
37789     try {
37790       (arg1)->AnimateBetween(arg2,*arg3);
37791     } catch (std::out_of_range& e) {
37792       {
37793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37794       };
37795     } catch (std::exception& e) {
37796       {
37797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37798       };
37799     } catch (...) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37802       };
37803     }
37804   }
37805 }
37806
37807
37808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
37809   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37810   SwigValueWrapper< Dali::Property > arg2 ;
37811   Dali::KeyFrames *arg3 = 0 ;
37812   Dali::Animation::Interpolation arg4 ;
37813   Dali::Property *argp2 ;
37814
37815   arg1 = (Dali::Animation *)jarg1;
37816   argp2 = (Dali::Property *)jarg2;
37817   if (!argp2) {
37818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37819     return ;
37820   }
37821   arg2 = *argp2;
37822   arg3 = (Dali::KeyFrames *)jarg3;
37823   if (!arg3) {
37824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
37825     return ;
37826   }
37827   arg4 = (Dali::Animation::Interpolation)jarg4;
37828   {
37829     try {
37830       (arg1)->AnimateBetween(arg2,*arg3,arg4);
37831     } catch (std::out_of_range& e) {
37832       {
37833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37834       };
37835     } catch (std::exception& e) {
37836       {
37837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37838       };
37839     } catch (...) {
37840       {
37841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37842       };
37843     }
37844   }
37845 }
37846
37847
37848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
37849   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37850   SwigValueWrapper< Dali::Property > arg2 ;
37851   Dali::KeyFrames *arg3 = 0 ;
37852   Dali::AlphaFunction arg4 ;
37853   Dali::Property *argp2 ;
37854   Dali::AlphaFunction *argp4 ;
37855
37856   arg1 = (Dali::Animation *)jarg1;
37857   argp2 = (Dali::Property *)jarg2;
37858   if (!argp2) {
37859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37860     return ;
37861   }
37862   arg2 = *argp2;
37863   arg3 = (Dali::KeyFrames *)jarg3;
37864   if (!arg3) {
37865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
37866     return ;
37867   }
37868   argp4 = (Dali::AlphaFunction *)jarg4;
37869   if (!argp4) {
37870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37871     return ;
37872   }
37873   arg4 = *argp4;
37874   {
37875     try {
37876       (arg1)->AnimateBetween(arg2,*arg3,arg4);
37877     } catch (std::out_of_range& e) {
37878       {
37879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37880       };
37881     } catch (std::exception& e) {
37882       {
37883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37884       };
37885     } catch (...) {
37886       {
37887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37888       };
37889     }
37890   }
37891 }
37892
37893
37894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
37895   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37896   SwigValueWrapper< Dali::Property > arg2 ;
37897   Dali::KeyFrames *arg3 = 0 ;
37898   Dali::AlphaFunction arg4 ;
37899   Dali::Animation::Interpolation arg5 ;
37900   Dali::Property *argp2 ;
37901   Dali::AlphaFunction *argp4 ;
37902
37903   arg1 = (Dali::Animation *)jarg1;
37904   argp2 = (Dali::Property *)jarg2;
37905   if (!argp2) {
37906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37907     return ;
37908   }
37909   arg2 = *argp2;
37910   arg3 = (Dali::KeyFrames *)jarg3;
37911   if (!arg3) {
37912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
37913     return ;
37914   }
37915   argp4 = (Dali::AlphaFunction *)jarg4;
37916   if (!argp4) {
37917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37918     return ;
37919   }
37920   arg4 = *argp4;
37921   arg5 = (Dali::Animation::Interpolation)jarg5;
37922   {
37923     try {
37924       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
37925     } catch (std::out_of_range& e) {
37926       {
37927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37928       };
37929     } catch (std::exception& e) {
37930       {
37931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37932       };
37933     } catch (...) {
37934       {
37935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37936       };
37937     }
37938   }
37939 }
37940
37941
37942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
37943   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37944   SwigValueWrapper< Dali::Property > arg2 ;
37945   Dali::KeyFrames *arg3 = 0 ;
37946   SwigValueWrapper< Dali::TimePeriod > arg4 ;
37947   Dali::Property *argp2 ;
37948   Dali::TimePeriod *argp4 ;
37949
37950   arg1 = (Dali::Animation *)jarg1;
37951   argp2 = (Dali::Property *)jarg2;
37952   if (!argp2) {
37953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
37954     return ;
37955   }
37956   arg2 = *argp2;
37957   arg3 = (Dali::KeyFrames *)jarg3;
37958   if (!arg3) {
37959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
37960     return ;
37961   }
37962   argp4 = (Dali::TimePeriod *)jarg4;
37963   if (!argp4) {
37964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
37965     return ;
37966   }
37967   arg4 = *argp4;
37968   {
37969     try {
37970       (arg1)->AnimateBetween(arg2,*arg3,arg4);
37971     } catch (std::out_of_range& e) {
37972       {
37973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37974       };
37975     } catch (std::exception& e) {
37976       {
37977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37978       };
37979     } catch (...) {
37980       {
37981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37982       };
37983     }
37984   }
37985 }
37986
37987
37988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
37989   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
37990   SwigValueWrapper< Dali::Property > arg2 ;
37991   Dali::KeyFrames *arg3 = 0 ;
37992   SwigValueWrapper< Dali::TimePeriod > arg4 ;
37993   Dali::Animation::Interpolation arg5 ;
37994   Dali::Property *argp2 ;
37995   Dali::TimePeriod *argp4 ;
37996
37997   arg1 = (Dali::Animation *)jarg1;
37998   argp2 = (Dali::Property *)jarg2;
37999   if (!argp2) {
38000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38001     return ;
38002   }
38003   arg2 = *argp2;
38004   arg3 = (Dali::KeyFrames *)jarg3;
38005   if (!arg3) {
38006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
38007     return ;
38008   }
38009   argp4 = (Dali::TimePeriod *)jarg4;
38010   if (!argp4) {
38011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
38012     return ;
38013   }
38014   arg4 = *argp4;
38015   arg5 = (Dali::Animation::Interpolation)jarg5;
38016   {
38017     try {
38018       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
38019     } catch (std::out_of_range& e) {
38020       {
38021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38022       };
38023     } catch (std::exception& e) {
38024       {
38025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38026       };
38027     } catch (...) {
38028       {
38029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38030       };
38031     }
38032   }
38033 }
38034
38035
38036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38037   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38038   SwigValueWrapper< Dali::Property > arg2 ;
38039   Dali::KeyFrames *arg3 = 0 ;
38040   Dali::AlphaFunction arg4 ;
38041   SwigValueWrapper< Dali::TimePeriod > arg5 ;
38042   Dali::Property *argp2 ;
38043   Dali::AlphaFunction *argp4 ;
38044   Dali::TimePeriod *argp5 ;
38045
38046   arg1 = (Dali::Animation *)jarg1;
38047   argp2 = (Dali::Property *)jarg2;
38048   if (!argp2) {
38049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38050     return ;
38051   }
38052   arg2 = *argp2;
38053   arg3 = (Dali::KeyFrames *)jarg3;
38054   if (!arg3) {
38055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
38056     return ;
38057   }
38058   argp4 = (Dali::AlphaFunction *)jarg4;
38059   if (!argp4) {
38060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38061     return ;
38062   }
38063   arg4 = *argp4;
38064   argp5 = (Dali::TimePeriod *)jarg5;
38065   if (!argp5) {
38066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
38067     return ;
38068   }
38069   arg5 = *argp5;
38070   {
38071     try {
38072       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
38073     } catch (std::out_of_range& e) {
38074       {
38075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38076       };
38077     } catch (std::exception& e) {
38078       {
38079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38080       };
38081     } catch (...) {
38082       {
38083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38084       };
38085     }
38086   }
38087 }
38088
38089
38090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
38091   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38092   SwigValueWrapper< Dali::Property > arg2 ;
38093   Dali::KeyFrames *arg3 = 0 ;
38094   Dali::AlphaFunction arg4 ;
38095   SwigValueWrapper< Dali::TimePeriod > arg5 ;
38096   Dali::Animation::Interpolation arg6 ;
38097   Dali::Property *argp2 ;
38098   Dali::AlphaFunction *argp4 ;
38099   Dali::TimePeriod *argp5 ;
38100
38101   arg1 = (Dali::Animation *)jarg1;
38102   argp2 = (Dali::Property *)jarg2;
38103   if (!argp2) {
38104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38105     return ;
38106   }
38107   arg2 = *argp2;
38108   arg3 = (Dali::KeyFrames *)jarg3;
38109   if (!arg3) {
38110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
38111     return ;
38112   }
38113   argp4 = (Dali::AlphaFunction *)jarg4;
38114   if (!argp4) {
38115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38116     return ;
38117   }
38118   arg4 = *argp4;
38119   argp5 = (Dali::TimePeriod *)jarg5;
38120   if (!argp5) {
38121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
38122     return ;
38123   }
38124   arg5 = *argp5;
38125   arg6 = (Dali::Animation::Interpolation)jarg6;
38126   {
38127     try {
38128       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
38129     } catch (std::out_of_range& e) {
38130       {
38131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38132       };
38133     } catch (std::exception& e) {
38134       {
38135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38136       };
38137     } catch (...) {
38138       {
38139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38140       };
38141     }
38142   }
38143 }
38144
38145
38146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
38147   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38148   Dali::Actor arg2 ;
38149   Dali::Path arg3 ;
38150   Dali::Vector3 *arg4 = 0 ;
38151   Dali::Actor *argp2 ;
38152   Dali::Path *argp3 ;
38153
38154   arg1 = (Dali::Animation *)jarg1;
38155   argp2 = (Dali::Actor *)jarg2;
38156   if (!argp2) {
38157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38158     return ;
38159   }
38160   arg2 = *argp2;
38161   argp3 = (Dali::Path *)jarg3;
38162   if (!argp3) {
38163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
38164     return ;
38165   }
38166   arg3 = *argp3;
38167   arg4 = (Dali::Vector3 *)jarg4;
38168   if (!arg4) {
38169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38170     return ;
38171   }
38172   {
38173     try {
38174       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
38175     } catch (std::out_of_range& e) {
38176       {
38177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38178       };
38179     } catch (std::exception& e) {
38180       {
38181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38182       };
38183     } catch (...) {
38184       {
38185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38186       };
38187     }
38188   }
38189 }
38190
38191
38192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38193   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38194   Dali::Actor arg2 ;
38195   Dali::Path arg3 ;
38196   Dali::Vector3 *arg4 = 0 ;
38197   Dali::AlphaFunction arg5 ;
38198   Dali::Actor *argp2 ;
38199   Dali::Path *argp3 ;
38200   Dali::AlphaFunction *argp5 ;
38201
38202   arg1 = (Dali::Animation *)jarg1;
38203   argp2 = (Dali::Actor *)jarg2;
38204   if (!argp2) {
38205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38206     return ;
38207   }
38208   arg2 = *argp2;
38209   argp3 = (Dali::Path *)jarg3;
38210   if (!argp3) {
38211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
38212     return ;
38213   }
38214   arg3 = *argp3;
38215   arg4 = (Dali::Vector3 *)jarg4;
38216   if (!arg4) {
38217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38218     return ;
38219   }
38220   argp5 = (Dali::AlphaFunction *)jarg5;
38221   if (!argp5) {
38222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38223     return ;
38224   }
38225   arg5 = *argp5;
38226   {
38227     try {
38228       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
38229     } catch (std::out_of_range& e) {
38230       {
38231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38232       };
38233     } catch (std::exception& e) {
38234       {
38235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38236       };
38237     } catch (...) {
38238       {
38239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38240       };
38241     }
38242   }
38243 }
38244
38245
38246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38247   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38248   Dali::Actor arg2 ;
38249   Dali::Path arg3 ;
38250   Dali::Vector3 *arg4 = 0 ;
38251   SwigValueWrapper< Dali::TimePeriod > arg5 ;
38252   Dali::Actor *argp2 ;
38253   Dali::Path *argp3 ;
38254   Dali::TimePeriod *argp5 ;
38255
38256   arg1 = (Dali::Animation *)jarg1;
38257   argp2 = (Dali::Actor *)jarg2;
38258   if (!argp2) {
38259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38260     return ;
38261   }
38262   arg2 = *argp2;
38263   argp3 = (Dali::Path *)jarg3;
38264   if (!argp3) {
38265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
38266     return ;
38267   }
38268   arg3 = *argp3;
38269   arg4 = (Dali::Vector3 *)jarg4;
38270   if (!arg4) {
38271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38272     return ;
38273   }
38274   argp5 = (Dali::TimePeriod *)jarg5;
38275   if (!argp5) {
38276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
38277     return ;
38278   }
38279   arg5 = *argp5;
38280   {
38281     try {
38282       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
38283     } catch (std::out_of_range& e) {
38284       {
38285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38286       };
38287     } catch (std::exception& e) {
38288       {
38289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38290       };
38291     } catch (...) {
38292       {
38293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38294       };
38295     }
38296   }
38297 }
38298
38299
38300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
38301   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38302   Dali::Actor arg2 ;
38303   Dali::Path arg3 ;
38304   Dali::Vector3 *arg4 = 0 ;
38305   Dali::AlphaFunction arg5 ;
38306   SwigValueWrapper< Dali::TimePeriod > arg6 ;
38307   Dali::Actor *argp2 ;
38308   Dali::Path *argp3 ;
38309   Dali::AlphaFunction *argp5 ;
38310   Dali::TimePeriod *argp6 ;
38311
38312   arg1 = (Dali::Animation *)jarg1;
38313   argp2 = (Dali::Actor *)jarg2;
38314   if (!argp2) {
38315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38316     return ;
38317   }
38318   arg2 = *argp2;
38319   argp3 = (Dali::Path *)jarg3;
38320   if (!argp3) {
38321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
38322     return ;
38323   }
38324   arg3 = *argp3;
38325   arg4 = (Dali::Vector3 *)jarg4;
38326   if (!arg4) {
38327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38328     return ;
38329   }
38330   argp5 = (Dali::AlphaFunction *)jarg5;
38331   if (!argp5) {
38332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38333     return ;
38334   }
38335   arg5 = *argp5;
38336   argp6 = (Dali::TimePeriod *)jarg6;
38337   if (!argp6) {
38338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
38339     return ;
38340   }
38341   arg6 = *argp6;
38342   {
38343     try {
38344       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
38345     } catch (std::out_of_range& e) {
38346       {
38347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38348       };
38349     } catch (std::exception& e) {
38350       {
38351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38352       };
38353     } catch (...) {
38354       {
38355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38356       };
38357     }
38358   }
38359 }
38360
38361
38362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
38363   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38364   Dali::Actor arg2 ;
38365   float arg3 ;
38366   Dali::Actor *argp2 ;
38367
38368   arg1 = (Dali::Animation *)jarg1;
38369   argp2 = (Dali::Actor *)jarg2;
38370   if (!argp2) {
38371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38372     return ;
38373   }
38374   arg2 = *argp2;
38375   arg3 = (float)jarg3;
38376   {
38377     try {
38378       (arg1)->Show(arg2,arg3);
38379     } catch (std::out_of_range& e) {
38380       {
38381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38382       };
38383     } catch (std::exception& e) {
38384       {
38385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38386       };
38387     } catch (...) {
38388       {
38389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38390       };
38391     }
38392   }
38393 }
38394
38395
38396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
38397   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38398   Dali::Actor arg2 ;
38399   float arg3 ;
38400   Dali::Actor *argp2 ;
38401
38402   arg1 = (Dali::Animation *)jarg1;
38403   argp2 = (Dali::Actor *)jarg2;
38404   if (!argp2) {
38405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
38406     return ;
38407   }
38408   arg2 = *argp2;
38409   arg3 = (float)jarg3;
38410   {
38411     try {
38412       (arg1)->Hide(arg2,arg3);
38413     } catch (std::out_of_range& e) {
38414       {
38415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38416       };
38417     } catch (std::exception& e) {
38418       {
38419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38420       };
38421     } catch (...) {
38422       {
38423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38424       };
38425     }
38426   }
38427 }
38428
38429
38430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
38431   int jresult ;
38432   int result;
38433
38434   result = (int)Dali::LinearConstrainer::Property::VALUE;
38435   jresult = (int)result;
38436   return jresult;
38437 }
38438
38439
38440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
38441   int jresult ;
38442   int result;
38443
38444   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
38445   jresult = (int)result;
38446   return jresult;
38447 }
38448
38449
38450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
38451   void * jresult ;
38452   Dali::LinearConstrainer::Property *result = 0 ;
38453
38454   {
38455     try {
38456       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
38457     } catch (std::out_of_range& e) {
38458       {
38459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38460       };
38461     } catch (std::exception& e) {
38462       {
38463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38464       };
38465     } catch (...) {
38466       {
38467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38468       };
38469     }
38470   }
38471   jresult = (void *)result;
38472   return jresult;
38473 }
38474
38475
38476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
38477   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
38478
38479   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
38480   {
38481     try {
38482       delete arg1;
38483     } catch (std::out_of_range& e) {
38484       {
38485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38486       };
38487     } catch (std::exception& e) {
38488       {
38489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38490       };
38491     } catch (...) {
38492       {
38493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38494       };
38495     }
38496   }
38497 }
38498
38499
38500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
38501   void * jresult ;
38502   Dali::LinearConstrainer result;
38503
38504   {
38505     try {
38506       result = Dali::LinearConstrainer::New();
38507     } catch (std::out_of_range& e) {
38508       {
38509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38510       };
38511     } catch (std::exception& e) {
38512       {
38513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38514       };
38515     } catch (...) {
38516       {
38517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38518       };
38519     }
38520   }
38521   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38522   return jresult;
38523 }
38524
38525
38526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
38527   void * jresult ;
38528   Dali::BaseHandle arg1 ;
38529   Dali::BaseHandle *argp1 ;
38530   Dali::LinearConstrainer result;
38531
38532   argp1 = (Dali::BaseHandle *)jarg1;
38533   if (!argp1) {
38534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38535     return 0;
38536   }
38537   arg1 = *argp1;
38538   {
38539     try {
38540       result = Dali::LinearConstrainer::DownCast(arg1);
38541     } catch (std::out_of_range& e) {
38542       {
38543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38544       };
38545     } catch (std::exception& e) {
38546       {
38547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38552       };
38553     }
38554   }
38555   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38556   return jresult;
38557 }
38558
38559
38560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
38561   void * jresult ;
38562   Dali::LinearConstrainer *result = 0 ;
38563
38564   {
38565     try {
38566       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
38567     } catch (std::out_of_range& e) {
38568       {
38569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38570       };
38571     } catch (std::exception& e) {
38572       {
38573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38574       };
38575     } catch (...) {
38576       {
38577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38578       };
38579     }
38580   }
38581   jresult = (void *)result;
38582   return jresult;
38583 }
38584
38585
38586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
38587   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38588
38589   arg1 = (Dali::LinearConstrainer *)jarg1;
38590   {
38591     try {
38592       delete arg1;
38593     } catch (std::out_of_range& e) {
38594       {
38595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38596       };
38597     } catch (std::exception& e) {
38598       {
38599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38600       };
38601     } catch (...) {
38602       {
38603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38604       };
38605     }
38606   }
38607 }
38608
38609
38610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
38611   void * jresult ;
38612   Dali::LinearConstrainer *arg1 = 0 ;
38613   Dali::LinearConstrainer *result = 0 ;
38614
38615   arg1 = (Dali::LinearConstrainer *)jarg1;
38616   if (!arg1) {
38617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38618     return 0;
38619   }
38620   {
38621     try {
38622       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
38623     } catch (std::out_of_range& e) {
38624       {
38625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38626       };
38627     } catch (std::exception& e) {
38628       {
38629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38630       };
38631     } catch (...) {
38632       {
38633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38634       };
38635     }
38636   }
38637   jresult = (void *)result;
38638   return jresult;
38639 }
38640
38641
38642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
38643   void * jresult ;
38644   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38645   Dali::LinearConstrainer *arg2 = 0 ;
38646   Dali::LinearConstrainer *result = 0 ;
38647
38648   arg1 = (Dali::LinearConstrainer *)jarg1;
38649   arg2 = (Dali::LinearConstrainer *)jarg2;
38650   if (!arg2) {
38651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38652     return 0;
38653   }
38654   {
38655     try {
38656       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
38657     } catch (std::out_of_range& e) {
38658       {
38659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38660       };
38661     } catch (std::exception& e) {
38662       {
38663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38664       };
38665     } catch (...) {
38666       {
38667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38668       };
38669     }
38670   }
38671   jresult = (void *)result;
38672   return jresult;
38673 }
38674
38675
38676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38677   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38678   SwigValueWrapper< Dali::Property > arg2 ;
38679   SwigValueWrapper< Dali::Property > arg3 ;
38680   Dali::Vector2 *arg4 = 0 ;
38681   Dali::Vector2 *arg5 = 0 ;
38682   Dali::Property *argp2 ;
38683   Dali::Property *argp3 ;
38684
38685   arg1 = (Dali::LinearConstrainer *)jarg1;
38686   argp2 = (Dali::Property *)jarg2;
38687   if (!argp2) {
38688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38689     return ;
38690   }
38691   arg2 = *argp2;
38692   argp3 = (Dali::Property *)jarg3;
38693   if (!argp3) {
38694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38695     return ;
38696   }
38697   arg3 = *argp3;
38698   arg4 = (Dali::Vector2 *)jarg4;
38699   if (!arg4) {
38700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38701     return ;
38702   }
38703   arg5 = (Dali::Vector2 *)jarg5;
38704   if (!arg5) {
38705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38706     return ;
38707   }
38708   {
38709     try {
38710       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
38711     } catch (std::out_of_range& e) {
38712       {
38713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38714       };
38715     } catch (std::exception& e) {
38716       {
38717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38718       };
38719     } catch (...) {
38720       {
38721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38722       };
38723     }
38724   }
38725 }
38726
38727
38728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
38729   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38730   SwigValueWrapper< Dali::Property > arg2 ;
38731   SwigValueWrapper< Dali::Property > arg3 ;
38732   Dali::Vector2 *arg4 = 0 ;
38733   Dali::Property *argp2 ;
38734   Dali::Property *argp3 ;
38735
38736   arg1 = (Dali::LinearConstrainer *)jarg1;
38737   argp2 = (Dali::Property *)jarg2;
38738   if (!argp2) {
38739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38740     return ;
38741   }
38742   arg2 = *argp2;
38743   argp3 = (Dali::Property *)jarg3;
38744   if (!argp3) {
38745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38746     return ;
38747   }
38748   arg3 = *argp3;
38749   arg4 = (Dali::Vector2 *)jarg4;
38750   if (!arg4) {
38751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38752     return ;
38753   }
38754   {
38755     try {
38756       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
38757     } catch (std::out_of_range& e) {
38758       {
38759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38760       };
38761     } catch (std::exception& e) {
38762       {
38763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38764       };
38765     } catch (...) {
38766       {
38767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38768       };
38769     }
38770   }
38771 }
38772
38773
38774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
38775   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38776   Dali::Handle *arg2 = 0 ;
38777
38778   arg1 = (Dali::LinearConstrainer *)jarg1;
38779   arg2 = (Dali::Handle *)jarg2;
38780   if (!arg2) {
38781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
38782     return ;
38783   }
38784   {
38785     try {
38786       (arg1)->Remove(*arg2);
38787     } catch (std::out_of_range& e) {
38788       {
38789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38790       };
38791     } catch (std::exception& e) {
38792       {
38793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38794       };
38795     } catch (...) {
38796       {
38797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38798       };
38799     }
38800   }
38801 }
38802
38803
38804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
38805   int jresult ;
38806   int result;
38807
38808   result = (int)Dali::PathConstrainer::Property::FORWARD;
38809   jresult = (int)result;
38810   return jresult;
38811 }
38812
38813
38814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
38815   int jresult ;
38816   int result;
38817
38818   result = (int)Dali::PathConstrainer::Property::POINTS;
38819   jresult = (int)result;
38820   return jresult;
38821 }
38822
38823
38824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
38825   int jresult ;
38826   int result;
38827
38828   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
38829   jresult = (int)result;
38830   return jresult;
38831 }
38832
38833
38834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
38835   void * jresult ;
38836   Dali::PathConstrainer::Property *result = 0 ;
38837
38838   {
38839     try {
38840       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
38841     } catch (std::out_of_range& e) {
38842       {
38843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38844       };
38845     } catch (std::exception& e) {
38846       {
38847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38848       };
38849     } catch (...) {
38850       {
38851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38852       };
38853     }
38854   }
38855   jresult = (void *)result;
38856   return jresult;
38857 }
38858
38859
38860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
38861   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
38862
38863   arg1 = (Dali::PathConstrainer::Property *)jarg1;
38864   {
38865     try {
38866       delete arg1;
38867     } catch (std::out_of_range& e) {
38868       {
38869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38870       };
38871     } catch (std::exception& e) {
38872       {
38873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38874       };
38875     } catch (...) {
38876       {
38877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38878       };
38879     }
38880   }
38881 }
38882
38883
38884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
38885   void * jresult ;
38886   Dali::PathConstrainer result;
38887
38888   {
38889     try {
38890       result = Dali::PathConstrainer::New();
38891     } catch (std::out_of_range& e) {
38892       {
38893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38894       };
38895     } catch (std::exception& e) {
38896       {
38897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38898       };
38899     } catch (...) {
38900       {
38901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38902       };
38903     }
38904   }
38905   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38906   return jresult;
38907 }
38908
38909
38910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
38911   void * jresult ;
38912   Dali::BaseHandle arg1 ;
38913   Dali::BaseHandle *argp1 ;
38914   Dali::PathConstrainer result;
38915
38916   argp1 = (Dali::BaseHandle *)jarg1;
38917   if (!argp1) {
38918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38919     return 0;
38920   }
38921   arg1 = *argp1;
38922   {
38923     try {
38924       result = Dali::PathConstrainer::DownCast(arg1);
38925     } catch (std::out_of_range& e) {
38926       {
38927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38928       };
38929     } catch (std::exception& e) {
38930       {
38931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38932       };
38933     } catch (...) {
38934       {
38935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38936       };
38937     }
38938   }
38939   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38940   return jresult;
38941 }
38942
38943
38944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
38945   void * jresult ;
38946   Dali::PathConstrainer *result = 0 ;
38947
38948   {
38949     try {
38950       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
38951     } catch (std::out_of_range& e) {
38952       {
38953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38954       };
38955     } catch (std::exception& e) {
38956       {
38957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38958       };
38959     } catch (...) {
38960       {
38961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38962       };
38963     }
38964   }
38965   jresult = (void *)result;
38966   return jresult;
38967 }
38968
38969
38970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
38971   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
38972
38973   arg1 = (Dali::PathConstrainer *)jarg1;
38974   {
38975     try {
38976       delete arg1;
38977     } catch (std::out_of_range& e) {
38978       {
38979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38980       };
38981     } catch (std::exception& e) {
38982       {
38983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38984       };
38985     } catch (...) {
38986       {
38987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38988       };
38989     }
38990   }
38991 }
38992
38993
38994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
38995   void * jresult ;
38996   Dali::PathConstrainer *arg1 = 0 ;
38997   Dali::PathConstrainer *result = 0 ;
38998
38999   arg1 = (Dali::PathConstrainer *)jarg1;
39000   if (!arg1) {
39001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39002     return 0;
39003   }
39004   {
39005     try {
39006       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
39007     } catch (std::out_of_range& e) {
39008       {
39009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39010       };
39011     } catch (std::exception& e) {
39012       {
39013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39014       };
39015     } catch (...) {
39016       {
39017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39018       };
39019     }
39020   }
39021   jresult = (void *)result;
39022   return jresult;
39023 }
39024
39025
39026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
39027   void * jresult ;
39028   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39029   Dali::PathConstrainer *arg2 = 0 ;
39030   Dali::PathConstrainer *result = 0 ;
39031
39032   arg1 = (Dali::PathConstrainer *)jarg1;
39033   arg2 = (Dali::PathConstrainer *)jarg2;
39034   if (!arg2) {
39035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39036     return 0;
39037   }
39038   {
39039     try {
39040       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
39041     } catch (std::out_of_range& e) {
39042       {
39043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39044       };
39045     } catch (std::exception& e) {
39046       {
39047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39048       };
39049     } catch (...) {
39050       {
39051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39052       };
39053     }
39054   }
39055   jresult = (void *)result;
39056   return jresult;
39057 }
39058
39059
39060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39061   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39062   SwigValueWrapper< Dali::Property > arg2 ;
39063   SwigValueWrapper< Dali::Property > arg3 ;
39064   Dali::Vector2 *arg4 = 0 ;
39065   Dali::Vector2 *arg5 = 0 ;
39066   Dali::Property *argp2 ;
39067   Dali::Property *argp3 ;
39068
39069   arg1 = (Dali::PathConstrainer *)jarg1;
39070   argp2 = (Dali::Property *)jarg2;
39071   if (!argp2) {
39072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39073     return ;
39074   }
39075   arg2 = *argp2;
39076   argp3 = (Dali::Property *)jarg3;
39077   if (!argp3) {
39078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39079     return ;
39080   }
39081   arg3 = *argp3;
39082   arg4 = (Dali::Vector2 *)jarg4;
39083   if (!arg4) {
39084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39085     return ;
39086   }
39087   arg5 = (Dali::Vector2 *)jarg5;
39088   if (!arg5) {
39089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39090     return ;
39091   }
39092   {
39093     try {
39094       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
39095     } catch (std::out_of_range& e) {
39096       {
39097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39098       };
39099     } catch (std::exception& e) {
39100       {
39101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39102       };
39103     } catch (...) {
39104       {
39105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39106       };
39107     }
39108   }
39109 }
39110
39111
39112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39113   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39114   SwigValueWrapper< Dali::Property > arg2 ;
39115   SwigValueWrapper< Dali::Property > arg3 ;
39116   Dali::Vector2 *arg4 = 0 ;
39117   Dali::Property *argp2 ;
39118   Dali::Property *argp3 ;
39119
39120   arg1 = (Dali::PathConstrainer *)jarg1;
39121   argp2 = (Dali::Property *)jarg2;
39122   if (!argp2) {
39123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39124     return ;
39125   }
39126   arg2 = *argp2;
39127   argp3 = (Dali::Property *)jarg3;
39128   if (!argp3) {
39129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39130     return ;
39131   }
39132   arg3 = *argp3;
39133   arg4 = (Dali::Vector2 *)jarg4;
39134   if (!arg4) {
39135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39136     return ;
39137   }
39138   {
39139     try {
39140       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
39141     } catch (std::out_of_range& e) {
39142       {
39143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39144       };
39145     } catch (std::exception& e) {
39146       {
39147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39148       };
39149     } catch (...) {
39150       {
39151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39152       };
39153     }
39154   }
39155 }
39156
39157
39158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
39159   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39160   Dali::Handle *arg2 = 0 ;
39161
39162   arg1 = (Dali::PathConstrainer *)jarg1;
39163   arg2 = (Dali::Handle *)jarg2;
39164   if (!arg2) {
39165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
39166     return ;
39167   }
39168   {
39169     try {
39170       (arg1)->Remove(*arg2);
39171     } catch (std::out_of_range& e) {
39172       {
39173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39174       };
39175     } catch (std::exception& e) {
39176       {
39177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39178       };
39179     } catch (...) {
39180       {
39181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39182       };
39183     }
39184   }
39185 }
39186
39187
39188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
39189   int jresult ;
39190   Dali::FittingMode::Type result;
39191
39192   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
39193   jresult = (int)result;
39194   return jresult;
39195 }
39196
39197
39198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
39199   int jresult ;
39200   Dali::SamplingMode::Type result;
39201
39202   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
39203   jresult = (int)result;
39204   return jresult;
39205 }
39206
39207
39208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
39209   void * jresult ;
39210   Dali::BufferImage *result = 0 ;
39211
39212   {
39213     try {
39214       result = (Dali::BufferImage *)new Dali::BufferImage();
39215     } catch (std::out_of_range& e) {
39216       {
39217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39218       };
39219     } catch (std::exception& e) {
39220       {
39221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39222       };
39223     } catch (...) {
39224       {
39225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39226       };
39227     }
39228   }
39229   jresult = (void *)result;
39230   return jresult;
39231 }
39232
39233
39234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
39235   void * jresult ;
39236   unsigned int arg1 ;
39237   unsigned int arg2 ;
39238   Dali::Pixel::Format arg3 ;
39239   Dali::BufferImage result;
39240
39241   arg1 = (unsigned int)jarg1;
39242   arg2 = (unsigned int)jarg2;
39243   arg3 = (Dali::Pixel::Format)jarg3;
39244   {
39245     try {
39246       result = Dali::BufferImage::New(arg1,arg2,arg3);
39247     } catch (std::out_of_range& e) {
39248       {
39249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39250       };
39251     } catch (std::exception& e) {
39252       {
39253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39254       };
39255     } catch (...) {
39256       {
39257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39258       };
39259     }
39260   }
39261   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39262   return jresult;
39263 }
39264
39265
39266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
39267   void * jresult ;
39268   unsigned int arg1 ;
39269   unsigned int arg2 ;
39270   Dali::BufferImage result;
39271
39272   arg1 = (unsigned int)jarg1;
39273   arg2 = (unsigned int)jarg2;
39274   {
39275     try {
39276       result = Dali::BufferImage::New(arg1,arg2);
39277     } catch (std::out_of_range& e) {
39278       {
39279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39280       };
39281     } catch (std::exception& e) {
39282       {
39283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39284       };
39285     } catch (...) {
39286       {
39287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39288       };
39289     }
39290   }
39291   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39292   return jresult;
39293 }
39294
39295
39296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
39297   void * jresult ;
39298   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39299   unsigned int arg2 ;
39300   unsigned int arg3 ;
39301   Dali::Pixel::Format arg4 ;
39302   unsigned int arg5 ;
39303   Dali::BufferImage result;
39304
39305   arg1 = jarg1;
39306   arg2 = (unsigned int)jarg2;
39307   arg3 = (unsigned int)jarg3;
39308   arg4 = (Dali::Pixel::Format)jarg4;
39309   arg5 = (unsigned int)jarg5;
39310   {
39311     try {
39312       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
39313     } catch (std::out_of_range& e) {
39314       {
39315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39316       };
39317     } catch (std::exception& e) {
39318       {
39319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39320       };
39321     } catch (...) {
39322       {
39323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39324       };
39325     }
39326   }
39327   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39328
39329
39330   return jresult;
39331 }
39332
39333
39334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
39335   void * jresult ;
39336   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39337   unsigned int arg2 ;
39338   unsigned int arg3 ;
39339   Dali::Pixel::Format arg4 ;
39340   Dali::BufferImage result;
39341
39342   arg1 = jarg1;
39343   arg2 = (unsigned int)jarg2;
39344   arg3 = (unsigned int)jarg3;
39345   arg4 = (Dali::Pixel::Format)jarg4;
39346   {
39347     try {
39348       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
39349     } catch (std::out_of_range& e) {
39350       {
39351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39352       };
39353     } catch (std::exception& e) {
39354       {
39355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39356       };
39357     } catch (...) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39360       };
39361     }
39362   }
39363   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39364
39365
39366   return jresult;
39367 }
39368
39369
39370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
39371   void * jresult ;
39372   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39373   unsigned int arg2 ;
39374   unsigned int arg3 ;
39375   Dali::BufferImage result;
39376
39377   arg1 = jarg1;
39378   arg2 = (unsigned int)jarg2;
39379   arg3 = (unsigned int)jarg3;
39380   {
39381     try {
39382       result = Dali::BufferImage::New(arg1,arg2,arg3);
39383     } catch (std::out_of_range& e) {
39384       {
39385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39386       };
39387     } catch (std::exception& e) {
39388       {
39389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39390       };
39391     } catch (...) {
39392       {
39393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39394       };
39395     }
39396   }
39397   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39398
39399
39400   return jresult;
39401 }
39402
39403
39404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
39405   void * jresult ;
39406   Dali::BaseHandle arg1 ;
39407   Dali::BaseHandle *argp1 ;
39408   Dali::BufferImage result;
39409
39410   argp1 = (Dali::BaseHandle *)jarg1;
39411   if (!argp1) {
39412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39413     return 0;
39414   }
39415   arg1 = *argp1;
39416   {
39417     try {
39418       result = Dali::BufferImage::DownCast(arg1);
39419     } catch (std::out_of_range& e) {
39420       {
39421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39422       };
39423     } catch (std::exception& e) {
39424       {
39425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39426       };
39427     } catch (...) {
39428       {
39429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39430       };
39431     }
39432   }
39433   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39434   return jresult;
39435 }
39436
39437
39438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
39439   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39440
39441   arg1 = (Dali::BufferImage *)jarg1;
39442   {
39443     try {
39444       delete arg1;
39445     } catch (std::out_of_range& e) {
39446       {
39447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39448       };
39449     } catch (std::exception& e) {
39450       {
39451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39452       };
39453     } catch (...) {
39454       {
39455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39456       };
39457     }
39458   }
39459 }
39460
39461
39462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
39463   void * jresult ;
39464   Dali::BufferImage *arg1 = 0 ;
39465   Dali::BufferImage *result = 0 ;
39466
39467   arg1 = (Dali::BufferImage *)jarg1;
39468   if (!arg1) {
39469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39470     return 0;
39471   }
39472   {
39473     try {
39474       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
39475     } catch (std::out_of_range& e) {
39476       {
39477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39478       };
39479     } catch (std::exception& e) {
39480       {
39481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39482       };
39483     } catch (...) {
39484       {
39485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39486       };
39487     }
39488   }
39489   jresult = (void *)result;
39490   return jresult;
39491 }
39492
39493
39494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
39495   void * jresult ;
39496   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39497   Dali::BufferImage *arg2 = 0 ;
39498   Dali::BufferImage *result = 0 ;
39499
39500   arg1 = (Dali::BufferImage *)jarg1;
39501   arg2 = (Dali::BufferImage *)jarg2;
39502   if (!arg2) {
39503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39504     return 0;
39505   }
39506   {
39507     try {
39508       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
39509     } catch (std::out_of_range& e) {
39510       {
39511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39512       };
39513     } catch (std::exception& e) {
39514       {
39515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39516       };
39517     } catch (...) {
39518       {
39519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39520       };
39521     }
39522   }
39523   jresult = (void *)result;
39524   return jresult;
39525 }
39526
39527
39528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
39529   void * jresult ;
39530   Dali::BufferImage result;
39531
39532   {
39533     try {
39534       result = Dali::BufferImage::WHITE();
39535     } catch (std::out_of_range& e) {
39536       {
39537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39538       };
39539     } catch (std::exception& e) {
39540       {
39541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39542       };
39543     } catch (...) {
39544       {
39545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39546       };
39547     }
39548   }
39549   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39550   return jresult;
39551 }
39552
39553
39554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
39555   void * jresult ;
39556   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39557   Dali::PixelBuffer *result = 0 ;
39558
39559   arg1 = (Dali::BufferImage *)jarg1;
39560   {
39561     try {
39562       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
39563     } catch (std::out_of_range& e) {
39564       {
39565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39566       };
39567     } catch (std::exception& e) {
39568       {
39569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39570       };
39571     } catch (...) {
39572       {
39573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39574       };
39575     }
39576   }
39577   jresult = (void *)result;
39578   return jresult;
39579 }
39580
39581
39582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
39583   unsigned int jresult ;
39584   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39585   unsigned int result;
39586
39587   arg1 = (Dali::BufferImage *)jarg1;
39588   {
39589     try {
39590       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
39591     } catch (std::out_of_range& e) {
39592       {
39593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39594       };
39595     } catch (std::exception& e) {
39596       {
39597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39598       };
39599     } catch (...) {
39600       {
39601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39602       };
39603     }
39604   }
39605   jresult = result;
39606   return jresult;
39607 }
39608
39609
39610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
39611   unsigned int jresult ;
39612   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39613   unsigned int result;
39614
39615   arg1 = (Dali::BufferImage *)jarg1;
39616   {
39617     try {
39618       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
39619     } catch (std::out_of_range& e) {
39620       {
39621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39622       };
39623     } catch (std::exception& e) {
39624       {
39625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39626       };
39627     } catch (...) {
39628       {
39629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39630       };
39631     }
39632   }
39633   jresult = result;
39634   return jresult;
39635 }
39636
39637
39638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
39639   int jresult ;
39640   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39641   Dali::Pixel::Format result;
39642
39643   arg1 = (Dali::BufferImage *)jarg1;
39644   {
39645     try {
39646       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
39647     } catch (std::out_of_range& e) {
39648       {
39649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39650       };
39651     } catch (std::exception& e) {
39652       {
39653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39654       };
39655     } catch (...) {
39656       {
39657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39658       };
39659     }
39660   }
39661   jresult = (int)result;
39662   return jresult;
39663 }
39664
39665
39666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
39667   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39668
39669   arg1 = (Dali::BufferImage *)jarg1;
39670   {
39671     try {
39672       (arg1)->Update();
39673     } catch (std::out_of_range& e) {
39674       {
39675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39676       };
39677     } catch (std::exception& e) {
39678       {
39679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39680       };
39681     } catch (...) {
39682       {
39683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39684       };
39685     }
39686   }
39687 }
39688
39689
39690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
39691   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39692   Dali::RectArea arg2 ;
39693   Dali::RectArea *argp2 ;
39694
39695   arg1 = (Dali::BufferImage *)jarg1;
39696   argp2 = (Dali::RectArea *)jarg2;
39697   if (!argp2) {
39698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
39699     return ;
39700   }
39701   arg2 = *argp2;
39702   {
39703     try {
39704       (arg1)->Update(arg2);
39705     } catch (std::out_of_range& e) {
39706       {
39707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39708       };
39709     } catch (std::exception& e) {
39710       {
39711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39712       };
39713     } catch (...) {
39714       {
39715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39716       };
39717     }
39718   }
39719 }
39720
39721
39722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
39723   unsigned int jresult ;
39724   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39725   bool result;
39726
39727   arg1 = (Dali::BufferImage *)jarg1;
39728   {
39729     try {
39730       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
39731     } catch (std::out_of_range& e) {
39732       {
39733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39734       };
39735     } catch (std::exception& e) {
39736       {
39737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39738       };
39739     } catch (...) {
39740       {
39741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39742       };
39743     }
39744   }
39745   jresult = result;
39746   return jresult;
39747 }
39748
39749
39750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
39751   void * jresult ;
39752   Dali::EncodedBufferImage *result = 0 ;
39753
39754   {
39755     try {
39756       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
39757     } catch (std::out_of_range& e) {
39758       {
39759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39760       };
39761     } catch (std::exception& e) {
39762       {
39763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39764       };
39765     } catch (...) {
39766       {
39767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39768       };
39769     }
39770   }
39771   jresult = (void *)result;
39772   return jresult;
39773 }
39774
39775
39776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
39777   void * jresult ;
39778   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39779   std::size_t arg2 ;
39780   Dali::EncodedBufferImage result;
39781
39782   arg1 = (uint8_t *)jarg1;
39783   arg2 = (std::size_t)jarg2;
39784   {
39785     try {
39786       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
39787     } catch (std::out_of_range& e) {
39788       {
39789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39790       };
39791     } catch (std::exception& e) {
39792       {
39793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39794       };
39795     } catch (...) {
39796       {
39797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39798       };
39799     }
39800   }
39801   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39802   return jresult;
39803 }
39804
39805
39806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
39807   void * jresult ;
39808   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39809   std::size_t arg2 ;
39810   Dali::ImageDimensions arg3 ;
39811   Dali::FittingMode::Type arg4 ;
39812   Dali::SamplingMode::Type arg5 ;
39813   bool arg6 ;
39814   Dali::ImageDimensions *argp3 ;
39815   Dali::EncodedBufferImage result;
39816
39817   arg1 = (uint8_t *)jarg1;
39818   arg2 = (std::size_t)jarg2;
39819   argp3 = (Dali::ImageDimensions *)jarg3;
39820   if (!argp3) {
39821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39822     return 0;
39823   }
39824   arg3 = *argp3;
39825   arg4 = (Dali::FittingMode::Type)jarg4;
39826   arg5 = (Dali::SamplingMode::Type)jarg5;
39827   arg6 = jarg6 ? true : false;
39828   {
39829     try {
39830       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
39831     } catch (std::out_of_range& e) {
39832       {
39833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39834       };
39835     } catch (std::exception& e) {
39836       {
39837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39838       };
39839     } catch (...) {
39840       {
39841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39842       };
39843     }
39844   }
39845   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39846   return jresult;
39847 }
39848
39849
39850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
39851   void * jresult ;
39852   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39853   std::size_t arg2 ;
39854   Dali::ImageDimensions arg3 ;
39855   Dali::FittingMode::Type arg4 ;
39856   Dali::SamplingMode::Type arg5 ;
39857   Dali::ImageDimensions *argp3 ;
39858   Dali::EncodedBufferImage result;
39859
39860   arg1 = (uint8_t *)jarg1;
39861   arg2 = (std::size_t)jarg2;
39862   argp3 = (Dali::ImageDimensions *)jarg3;
39863   if (!argp3) {
39864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39865     return 0;
39866   }
39867   arg3 = *argp3;
39868   arg4 = (Dali::FittingMode::Type)jarg4;
39869   arg5 = (Dali::SamplingMode::Type)jarg5;
39870   {
39871     try {
39872       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
39873     } catch (std::out_of_range& e) {
39874       {
39875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39876       };
39877     } catch (std::exception& e) {
39878       {
39879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39880       };
39881     } catch (...) {
39882       {
39883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39884       };
39885     }
39886   }
39887   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39888   return jresult;
39889 }
39890
39891
39892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
39893   void * jresult ;
39894   Dali::BaseHandle arg1 ;
39895   Dali::BaseHandle *argp1 ;
39896   Dali::EncodedBufferImage result;
39897
39898   argp1 = (Dali::BaseHandle *)jarg1;
39899   if (!argp1) {
39900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39901     return 0;
39902   }
39903   arg1 = *argp1;
39904   {
39905     try {
39906       result = Dali::EncodedBufferImage::DownCast(arg1);
39907     } catch (std::out_of_range& e) {
39908       {
39909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39910       };
39911     } catch (std::exception& e) {
39912       {
39913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39914       };
39915     } catch (...) {
39916       {
39917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39918       };
39919     }
39920   }
39921   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39922   return jresult;
39923 }
39924
39925
39926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
39927   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39928
39929   arg1 = (Dali::EncodedBufferImage *)jarg1;
39930   {
39931     try {
39932       delete arg1;
39933     } catch (std::out_of_range& e) {
39934       {
39935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39936       };
39937     } catch (std::exception& e) {
39938       {
39939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39940       };
39941     } catch (...) {
39942       {
39943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39944       };
39945     }
39946   }
39947 }
39948
39949
39950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
39951   void * jresult ;
39952   Dali::EncodedBufferImage *arg1 = 0 ;
39953   Dali::EncodedBufferImage *result = 0 ;
39954
39955   arg1 = (Dali::EncodedBufferImage *)jarg1;
39956   if (!arg1) {
39957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39958     return 0;
39959   }
39960   {
39961     try {
39962       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
39963     } catch (std::out_of_range& e) {
39964       {
39965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39966       };
39967     } catch (std::exception& e) {
39968       {
39969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39970       };
39971     } catch (...) {
39972       {
39973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39974       };
39975     }
39976   }
39977   jresult = (void *)result;
39978   return jresult;
39979 }
39980
39981
39982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
39983   void * jresult ;
39984   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39985   Dali::EncodedBufferImage *arg2 = 0 ;
39986   Dali::EncodedBufferImage *result = 0 ;
39987
39988   arg1 = (Dali::EncodedBufferImage *)jarg1;
39989   arg2 = (Dali::EncodedBufferImage *)jarg2;
39990   if (!arg2) {
39991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39992     return 0;
39993   }
39994   {
39995     try {
39996       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
39997     } catch (std::out_of_range& e) {
39998       {
39999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40000       };
40001     } catch (std::exception& e) {
40002       {
40003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40004       };
40005     } catch (...) {
40006       {
40007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40008       };
40009     }
40010   }
40011   jresult = (void *)result;
40012   return jresult;
40013 }
40014
40015
40016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
40017   void * jresult ;
40018   Dali::NativeImage *result = 0 ;
40019
40020   {
40021     try {
40022       result = (Dali::NativeImage *)new Dali::NativeImage();
40023     } catch (std::out_of_range& e) {
40024       {
40025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40026       };
40027     } catch (std::exception& e) {
40028       {
40029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40030       };
40031     } catch (...) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40034       };
40035     }
40036   }
40037   jresult = (void *)result;
40038   return jresult;
40039 }
40040
40041
40042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
40043   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40044
40045   arg1 = (Dali::NativeImage *)jarg1;
40046   {
40047     try {
40048       delete arg1;
40049     } catch (std::out_of_range& e) {
40050       {
40051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40052       };
40053     } catch (std::exception& e) {
40054       {
40055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40056       };
40057     } catch (...) {
40058       {
40059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40060       };
40061     }
40062   }
40063 }
40064
40065
40066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
40067   void * jresult ;
40068   Dali::NativeImage *arg1 = 0 ;
40069   Dali::NativeImage *result = 0 ;
40070
40071   arg1 = (Dali::NativeImage *)jarg1;
40072   if (!arg1) {
40073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40074     return 0;
40075   }
40076   {
40077     try {
40078       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
40079     } catch (std::out_of_range& e) {
40080       {
40081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40082       };
40083     } catch (std::exception& e) {
40084       {
40085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40086       };
40087     } catch (...) {
40088       {
40089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40090       };
40091     }
40092   }
40093   jresult = (void *)result;
40094   return jresult;
40095 }
40096
40097
40098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
40099   void * jresult ;
40100   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40101   Dali::NativeImage *arg2 = 0 ;
40102   Dali::NativeImage *result = 0 ;
40103
40104   arg1 = (Dali::NativeImage *)jarg1;
40105   arg2 = (Dali::NativeImage *)jarg2;
40106   if (!arg2) {
40107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40108     return 0;
40109   }
40110   {
40111     try {
40112       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
40113     } catch (std::out_of_range& e) {
40114       {
40115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40116       };
40117     } catch (std::exception& e) {
40118       {
40119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40120       };
40121     } catch (...) {
40122       {
40123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40124       };
40125     }
40126   }
40127   jresult = (void *)result;
40128   return jresult;
40129 }
40130
40131
40132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
40133   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40134
40135   arg1 = (Dali::NativeImage *)jarg1;
40136   {
40137     try {
40138       (arg1)->CreateGlTexture();
40139     } catch (std::out_of_range& e) {
40140       {
40141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40142       };
40143     } catch (std::exception& e) {
40144       {
40145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40146       };
40147     } catch (...) {
40148       {
40149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40150       };
40151     }
40152   }
40153 }
40154
40155
40156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
40157   void * jresult ;
40158   NativeImageInterface *arg1 = 0 ;
40159   Dali::NativeImage result;
40160
40161   arg1 = (NativeImageInterface *)jarg1;
40162   if (!arg1) {
40163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
40164     return 0;
40165   }
40166   {
40167     try {
40168       result = Dali::NativeImage::New(*arg1);
40169     } catch (std::out_of_range& e) {
40170       {
40171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40172       };
40173     } catch (std::exception& e) {
40174       {
40175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40176       };
40177     } catch (...) {
40178       {
40179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40180       };
40181     }
40182   }
40183   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40184   return jresult;
40185 }
40186
40187
40188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
40189   void * jresult ;
40190   Dali::BaseHandle arg1 ;
40191   Dali::BaseHandle *argp1 ;
40192   Dali::NativeImage result;
40193
40194   argp1 = (Dali::BaseHandle *)jarg1;
40195   if (!argp1) {
40196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40197     return 0;
40198   }
40199   arg1 = *argp1;
40200   {
40201     try {
40202       result = Dali::NativeImage::DownCast(arg1);
40203     } catch (std::out_of_range& e) {
40204       {
40205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40206       };
40207     } catch (std::exception& e) {
40208       {
40209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40210       };
40211     } catch (...) {
40212       {
40213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40214       };
40215     }
40216   }
40217   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40218   return jresult;
40219 }
40220
40221
40222 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
40223   char * jresult ;
40224   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40225   char *result = 0 ;
40226
40227   arg1 = (Dali::NativeImage *)jarg1;
40228   {
40229     try {
40230       result = (char *)(arg1)->GetCustomFragmentPreFix();
40231     } catch (std::out_of_range& e) {
40232       {
40233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40234       };
40235     } catch (std::exception& e) {
40236       {
40237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40238       };
40239     } catch (...) {
40240       {
40241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40242       };
40243     }
40244   }
40245   jresult = SWIG_csharp_string_callback((const char *)result);
40246   return jresult;
40247 }
40248
40249
40250 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
40251   char * jresult ;
40252   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40253   char *result = 0 ;
40254
40255   arg1 = (Dali::NativeImage *)jarg1;
40256   {
40257     try {
40258       result = (char *)(arg1)->GetCustomSamplerTypename();
40259     } catch (std::out_of_range& e) {
40260       {
40261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40262       };
40263     } catch (std::exception& e) {
40264       {
40265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40266       };
40267     } catch (...) {
40268       {
40269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40270       };
40271     }
40272   }
40273   jresult = SWIG_csharp_string_callback((const char *)result);
40274   return jresult;
40275 }
40276
40277
40278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
40279   unsigned int jresult ;
40280   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40281   bool result;
40282
40283   arg1 = (Dali::NativeImageInterface *)jarg1;
40284   {
40285     try {
40286       result = (bool)(arg1)->GlExtensionCreate();
40287     } catch (std::out_of_range& e) {
40288       {
40289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40290       };
40291     } catch (std::exception& e) {
40292       {
40293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40294       };
40295     } catch (...) {
40296       {
40297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40298       };
40299     }
40300   }
40301   jresult = result;
40302   return jresult;
40303 }
40304
40305
40306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
40307   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40308
40309   arg1 = (Dali::NativeImageInterface *)jarg1;
40310   {
40311     try {
40312       (arg1)->GlExtensionDestroy();
40313     } catch (std::out_of_range& e) {
40314       {
40315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40316       };
40317     } catch (std::exception& e) {
40318       {
40319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40320       };
40321     } catch (...) {
40322       {
40323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40324       };
40325     }
40326   }
40327 }
40328
40329
40330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
40331   unsigned int jresult ;
40332   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40333   unsigned int result;
40334
40335   arg1 = (Dali::NativeImageInterface *)jarg1;
40336   {
40337     try {
40338       result = (unsigned int)(arg1)->TargetTexture();
40339     } catch (std::out_of_range& e) {
40340       {
40341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40342       };
40343     } catch (std::exception& e) {
40344       {
40345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40346       };
40347     } catch (...) {
40348       {
40349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40350       };
40351     }
40352   }
40353   jresult = result;
40354   return jresult;
40355 }
40356
40357
40358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
40359   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40360
40361   arg1 = (Dali::NativeImageInterface *)jarg1;
40362   {
40363     try {
40364       (arg1)->PrepareTexture();
40365     } catch (std::out_of_range& e) {
40366       {
40367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40368       };
40369     } catch (std::exception& e) {
40370       {
40371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40372       };
40373     } catch (...) {
40374       {
40375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40376       };
40377     }
40378   }
40379 }
40380
40381
40382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
40383   unsigned int jresult ;
40384   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40385   unsigned int result;
40386
40387   arg1 = (Dali::NativeImageInterface *)jarg1;
40388   {
40389     try {
40390       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
40391     } catch (std::out_of_range& e) {
40392       {
40393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40394       };
40395     } catch (std::exception& e) {
40396       {
40397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40398       };
40399     } catch (...) {
40400       {
40401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40402       };
40403     }
40404   }
40405   jresult = result;
40406   return jresult;
40407 }
40408
40409
40410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
40411   unsigned int jresult ;
40412   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40413   unsigned int result;
40414
40415   arg1 = (Dali::NativeImageInterface *)jarg1;
40416   {
40417     try {
40418       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
40419     } catch (std::out_of_range& e) {
40420       {
40421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40422       };
40423     } catch (std::exception& e) {
40424       {
40425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40426       };
40427     } catch (...) {
40428       {
40429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40430       };
40431     }
40432   }
40433   jresult = result;
40434   return jresult;
40435 }
40436
40437
40438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
40439   unsigned int jresult ;
40440   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40441   bool result;
40442
40443   arg1 = (Dali::NativeImageInterface *)jarg1;
40444   {
40445     try {
40446       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
40447     } catch (std::out_of_range& e) {
40448       {
40449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40450       };
40451     } catch (std::exception& e) {
40452       {
40453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40454       };
40455     } catch (...) {
40456       {
40457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40458       };
40459     }
40460   }
40461   jresult = result;
40462   return jresult;
40463 }
40464
40465
40466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
40467   void * jresult ;
40468   std::string *arg1 = 0 ;
40469   Dali::ImageDimensions result;
40470
40471   if (!jarg1) {
40472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40473     return 0;
40474   }
40475   std::string arg1_str(jarg1);
40476   arg1 = &arg1_str;
40477   {
40478     try {
40479       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
40480     } catch (std::out_of_range& e) {
40481       {
40482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40483       };
40484     } catch (std::exception& e) {
40485       {
40486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40487       };
40488     } catch (...) {
40489       {
40490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40491       };
40492     }
40493   }
40494   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
40495
40496   //argout typemap for const std::string&
40497
40498   return jresult;
40499 }
40500
40501
40502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
40503   void * jresult ;
40504   Dali::ResourceImage *result = 0 ;
40505
40506   {
40507     try {
40508       result = (Dali::ResourceImage *)new Dali::ResourceImage();
40509     } catch (std::out_of_range& e) {
40510       {
40511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40512       };
40513     } catch (std::exception& e) {
40514       {
40515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40516       };
40517     } catch (...) {
40518       {
40519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40520       };
40521     }
40522   }
40523   jresult = (void *)result;
40524   return jresult;
40525 }
40526
40527
40528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
40529   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40530
40531   arg1 = (Dali::ResourceImage *)jarg1;
40532   {
40533     try {
40534       delete arg1;
40535     } catch (std::out_of_range& e) {
40536       {
40537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40538       };
40539     } catch (std::exception& e) {
40540       {
40541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40542       };
40543     } catch (...) {
40544       {
40545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40546       };
40547     }
40548   }
40549 }
40550
40551
40552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
40553   void * jresult ;
40554   Dali::ResourceImage *arg1 = 0 ;
40555   Dali::ResourceImage *result = 0 ;
40556
40557   arg1 = (Dali::ResourceImage *)jarg1;
40558   if (!arg1) {
40559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40560     return 0;
40561   }
40562   {
40563     try {
40564       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
40565     } catch (std::out_of_range& e) {
40566       {
40567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40568       };
40569     } catch (std::exception& e) {
40570       {
40571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40572       };
40573     } catch (...) {
40574       {
40575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40576       };
40577     }
40578   }
40579   jresult = (void *)result;
40580   return jresult;
40581 }
40582
40583
40584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
40585   void * jresult ;
40586   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40587   Dali::ResourceImage *arg2 = 0 ;
40588   Dali::ResourceImage *result = 0 ;
40589
40590   arg1 = (Dali::ResourceImage *)jarg1;
40591   arg2 = (Dali::ResourceImage *)jarg2;
40592   if (!arg2) {
40593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40594     return 0;
40595   }
40596   {
40597     try {
40598       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
40599     } catch (std::out_of_range& e) {
40600       {
40601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40602       };
40603     } catch (std::exception& e) {
40604       {
40605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40606       };
40607     } catch (...) {
40608       {
40609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40610       };
40611     }
40612   }
40613   jresult = (void *)result;
40614   return jresult;
40615 }
40616
40617
40618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
40619   void * jresult ;
40620   std::string *arg1 = 0 ;
40621   bool arg2 ;
40622   Dali::ResourceImage result;
40623
40624   if (!jarg1) {
40625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40626     return 0;
40627   }
40628   std::string arg1_str(jarg1);
40629   arg1 = &arg1_str;
40630   arg2 = jarg2 ? true : false;
40631   {
40632     try {
40633       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40634     } catch (std::out_of_range& e) {
40635       {
40636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40637       };
40638     } catch (std::exception& e) {
40639       {
40640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40641       };
40642     } catch (...) {
40643       {
40644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40645       };
40646     }
40647   }
40648   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40649
40650   //argout typemap for const std::string&
40651
40652   return jresult;
40653 }
40654
40655
40656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
40657   void * jresult ;
40658   std::string *arg1 = 0 ;
40659   Dali::ResourceImage result;
40660
40661   if (!jarg1) {
40662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40663     return 0;
40664   }
40665   std::string arg1_str(jarg1);
40666   arg1 = &arg1_str;
40667   {
40668     try {
40669       result = Dali::ResourceImage::New((std::string const &)*arg1);
40670     } catch (std::out_of_range& e) {
40671       {
40672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40673       };
40674     } catch (std::exception& e) {
40675       {
40676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40677       };
40678     } catch (...) {
40679       {
40680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40681       };
40682     }
40683   }
40684   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40685
40686   //argout typemap for const std::string&
40687
40688   return jresult;
40689 }
40690
40691
40692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
40693   void * jresult ;
40694   std::string *arg1 = 0 ;
40695   Dali::ImageDimensions arg2 ;
40696   Dali::FittingMode::Type arg3 ;
40697   Dali::SamplingMode::Type arg4 ;
40698   bool arg5 ;
40699   Dali::ImageDimensions *argp2 ;
40700   Dali::ResourceImage result;
40701
40702   if (!jarg1) {
40703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40704     return 0;
40705   }
40706   std::string arg1_str(jarg1);
40707   arg1 = &arg1_str;
40708   argp2 = (Dali::ImageDimensions *)jarg2;
40709   if (!argp2) {
40710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40711     return 0;
40712   }
40713   arg2 = *argp2;
40714   arg3 = (Dali::FittingMode::Type)jarg3;
40715   arg4 = (Dali::SamplingMode::Type)jarg4;
40716   arg5 = jarg5 ? true : false;
40717   {
40718     try {
40719       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
40720     } catch (std::out_of_range& e) {
40721       {
40722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40723       };
40724     } catch (std::exception& e) {
40725       {
40726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40727       };
40728     } catch (...) {
40729       {
40730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40731       };
40732     }
40733   }
40734   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40735
40736   //argout typemap for const std::string&
40737
40738   return jresult;
40739 }
40740
40741
40742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
40743   void * jresult ;
40744   std::string *arg1 = 0 ;
40745   Dali::ImageDimensions arg2 ;
40746   Dali::FittingMode::Type arg3 ;
40747   Dali::SamplingMode::Type arg4 ;
40748   Dali::ImageDimensions *argp2 ;
40749   Dali::ResourceImage result;
40750
40751   if (!jarg1) {
40752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40753     return 0;
40754   }
40755   std::string arg1_str(jarg1);
40756   arg1 = &arg1_str;
40757   argp2 = (Dali::ImageDimensions *)jarg2;
40758   if (!argp2) {
40759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40760     return 0;
40761   }
40762   arg2 = *argp2;
40763   arg3 = (Dali::FittingMode::Type)jarg3;
40764   arg4 = (Dali::SamplingMode::Type)jarg4;
40765   {
40766     try {
40767       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
40768     } catch (std::out_of_range& e) {
40769       {
40770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40771       };
40772     } catch (std::exception& e) {
40773       {
40774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40775       };
40776     } catch (...) {
40777       {
40778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40779       };
40780     }
40781   }
40782   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40783
40784   //argout typemap for const std::string&
40785
40786   return jresult;
40787 }
40788
40789
40790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
40791   void * jresult ;
40792   std::string *arg1 = 0 ;
40793   Dali::ImageDimensions arg2 ;
40794   Dali::FittingMode::Type arg3 ;
40795   Dali::ImageDimensions *argp2 ;
40796   Dali::ResourceImage result;
40797
40798   if (!jarg1) {
40799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40800     return 0;
40801   }
40802   std::string arg1_str(jarg1);
40803   arg1 = &arg1_str;
40804   argp2 = (Dali::ImageDimensions *)jarg2;
40805   if (!argp2) {
40806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40807     return 0;
40808   }
40809   arg2 = *argp2;
40810   arg3 = (Dali::FittingMode::Type)jarg3;
40811   {
40812     try {
40813       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
40814     } catch (std::out_of_range& e) {
40815       {
40816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40817       };
40818     } catch (std::exception& e) {
40819       {
40820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40821       };
40822     } catch (...) {
40823       {
40824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40825       };
40826     }
40827   }
40828   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40829
40830   //argout typemap for const std::string&
40831
40832   return jresult;
40833 }
40834
40835
40836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
40837   void * jresult ;
40838   std::string *arg1 = 0 ;
40839   Dali::ImageDimensions arg2 ;
40840   Dali::ImageDimensions *argp2 ;
40841   Dali::ResourceImage result;
40842
40843   if (!jarg1) {
40844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40845     return 0;
40846   }
40847   std::string arg1_str(jarg1);
40848   arg1 = &arg1_str;
40849   argp2 = (Dali::ImageDimensions *)jarg2;
40850   if (!argp2) {
40851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40852     return 0;
40853   }
40854   arg2 = *argp2;
40855   {
40856     try {
40857       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40858     } catch (std::out_of_range& e) {
40859       {
40860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40861       };
40862     } catch (std::exception& e) {
40863       {
40864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40865       };
40866     } catch (...) {
40867       {
40868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40869       };
40870     }
40871   }
40872   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40873
40874   //argout typemap for const std::string&
40875
40876   return jresult;
40877 }
40878
40879
40880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
40881   void * jresult ;
40882   Dali::BaseHandle arg1 ;
40883   Dali::BaseHandle *argp1 ;
40884   Dali::ResourceImage result;
40885
40886   argp1 = (Dali::BaseHandle *)jarg1;
40887   if (!argp1) {
40888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40889     return 0;
40890   }
40891   arg1 = *argp1;
40892   {
40893     try {
40894       result = Dali::ResourceImage::DownCast(arg1);
40895     } catch (std::out_of_range& e) {
40896       {
40897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40898       };
40899     } catch (std::exception& e) {
40900       {
40901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40902       };
40903     } catch (...) {
40904       {
40905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40906       };
40907     }
40908   }
40909   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40910   return jresult;
40911 }
40912
40913
40914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
40915   int jresult ;
40916   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40917   Dali::LoadingState result;
40918
40919   arg1 = (Dali::ResourceImage *)jarg1;
40920   {
40921     try {
40922       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
40923     } catch (std::out_of_range& e) {
40924       {
40925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40926       };
40927     } catch (std::exception& e) {
40928       {
40929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40930       };
40931     } catch (...) {
40932       {
40933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40934       };
40935     }
40936   }
40937   jresult = (int)result;
40938   return jresult;
40939 }
40940
40941
40942 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
40943   char * jresult ;
40944   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40945   std::string result;
40946
40947   arg1 = (Dali::ResourceImage *)jarg1;
40948   {
40949     try {
40950       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
40951     } catch (std::out_of_range& e) {
40952       {
40953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40954       };
40955     } catch (std::exception& e) {
40956       {
40957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40958       };
40959     } catch (...) {
40960       {
40961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40962       };
40963     }
40964   }
40965   jresult = SWIG_csharp_string_callback((&result)->c_str());
40966   return jresult;
40967 }
40968
40969
40970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
40971   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40972
40973   arg1 = (Dali::ResourceImage *)jarg1;
40974   {
40975     try {
40976       (arg1)->Reload();
40977     } catch (std::out_of_range& e) {
40978       {
40979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40980       };
40981     } catch (std::exception& e) {
40982       {
40983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40984       };
40985     } catch (...) {
40986       {
40987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40988       };
40989     }
40990   }
40991 }
40992
40993
40994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
40995   void * jresult ;
40996   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40997   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
40998
40999   arg1 = (Dali::ResourceImage *)jarg1;
41000   {
41001     try {
41002       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
41003     } catch (std::out_of_range& e) {
41004       {
41005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41006       };
41007     } catch (std::exception& e) {
41008       {
41009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41010       };
41011     } catch (...) {
41012       {
41013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41014       };
41015     }
41016   }
41017   jresult = (void *)result;
41018   return jresult;
41019 }
41020
41021
41022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
41023   void * jresult ;
41024   Dali::FrameBufferImage *result = 0 ;
41025
41026   {
41027     try {
41028       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
41029     } catch (std::out_of_range& e) {
41030       {
41031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41032       };
41033     } catch (std::exception& e) {
41034       {
41035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41036       };
41037     } catch (...) {
41038       {
41039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41040       };
41041     }
41042   }
41043   jresult = (void *)result;
41044   return jresult;
41045 }
41046
41047
41048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
41049   void * jresult ;
41050   unsigned int arg1 ;
41051   unsigned int arg2 ;
41052   Dali::Pixel::Format arg3 ;
41053   Dali::RenderBuffer::Format arg4 ;
41054   Dali::FrameBufferImage result;
41055
41056   arg1 = (unsigned int)jarg1;
41057   arg2 = (unsigned int)jarg2;
41058   arg3 = (Dali::Pixel::Format)jarg3;
41059   arg4 = (Dali::RenderBuffer::Format)jarg4;
41060   {
41061     try {
41062       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
41063     } catch (std::out_of_range& e) {
41064       {
41065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41066       };
41067     } catch (std::exception& e) {
41068       {
41069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41070       };
41071     } catch (...) {
41072       {
41073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41074       };
41075     }
41076   }
41077   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41078   return jresult;
41079 }
41080
41081
41082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41083   void * jresult ;
41084   unsigned int arg1 ;
41085   unsigned int arg2 ;
41086   Dali::Pixel::Format arg3 ;
41087   Dali::FrameBufferImage result;
41088
41089   arg1 = (unsigned int)jarg1;
41090   arg2 = (unsigned int)jarg2;
41091   arg3 = (Dali::Pixel::Format)jarg3;
41092   {
41093     try {
41094       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
41095     } catch (std::out_of_range& e) {
41096       {
41097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41098       };
41099     } catch (std::exception& e) {
41100       {
41101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41102       };
41103     } catch (...) {
41104       {
41105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41106       };
41107     }
41108   }
41109   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41110   return jresult;
41111 }
41112
41113
41114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
41115   void * jresult ;
41116   unsigned int arg1 ;
41117   unsigned int arg2 ;
41118   Dali::FrameBufferImage result;
41119
41120   arg1 = (unsigned int)jarg1;
41121   arg2 = (unsigned int)jarg2;
41122   {
41123     try {
41124       result = Dali::FrameBufferImage::New(arg1,arg2);
41125     } catch (std::out_of_range& e) {
41126       {
41127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41128       };
41129     } catch (std::exception& e) {
41130       {
41131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41132       };
41133     } catch (...) {
41134       {
41135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41136       };
41137     }
41138   }
41139   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41140   return jresult;
41141 }
41142
41143
41144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
41145   void * jresult ;
41146   unsigned int arg1 ;
41147   Dali::FrameBufferImage result;
41148
41149   arg1 = (unsigned int)jarg1;
41150   {
41151     try {
41152       result = Dali::FrameBufferImage::New(arg1);
41153     } catch (std::out_of_range& e) {
41154       {
41155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41156       };
41157     } catch (std::exception& e) {
41158       {
41159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41160       };
41161     } catch (...) {
41162       {
41163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41164       };
41165     }
41166   }
41167   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41168   return jresult;
41169 }
41170
41171
41172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
41173   void * jresult ;
41174   Dali::FrameBufferImage result;
41175
41176   {
41177     try {
41178       result = Dali::FrameBufferImage::New();
41179     } catch (std::out_of_range& e) {
41180       {
41181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41182       };
41183     } catch (std::exception& e) {
41184       {
41185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41186       };
41187     } catch (...) {
41188       {
41189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41190       };
41191     }
41192   }
41193   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41194   return jresult;
41195 }
41196
41197
41198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
41199   void * jresult ;
41200   Dali::NativeImageInterface *arg1 = 0 ;
41201   Dali::FrameBufferImage result;
41202
41203   arg1 = (Dali::NativeImageInterface *)jarg1;
41204   if (!arg1) {
41205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
41206     return 0;
41207   }
41208   {
41209     try {
41210       result = Dali::FrameBufferImage::New(*arg1);
41211     } catch (std::out_of_range& e) {
41212       {
41213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41214       };
41215     } catch (std::exception& e) {
41216       {
41217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41218       };
41219     } catch (...) {
41220       {
41221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41222       };
41223     }
41224   }
41225   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41226   return jresult;
41227 }
41228
41229
41230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
41231   void * jresult ;
41232   Dali::BaseHandle arg1 ;
41233   Dali::BaseHandle *argp1 ;
41234   Dali::FrameBufferImage result;
41235
41236   argp1 = (Dali::BaseHandle *)jarg1;
41237   if (!argp1) {
41238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41239     return 0;
41240   }
41241   arg1 = *argp1;
41242   {
41243     try {
41244       result = Dali::FrameBufferImage::DownCast(arg1);
41245     } catch (std::out_of_range& e) {
41246       {
41247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41248       };
41249     } catch (std::exception& e) {
41250       {
41251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41252       };
41253     } catch (...) {
41254       {
41255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41256       };
41257     }
41258   }
41259   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41260   return jresult;
41261 }
41262
41263
41264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
41265   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41266
41267   arg1 = (Dali::FrameBufferImage *)jarg1;
41268   {
41269     try {
41270       delete arg1;
41271     } catch (std::out_of_range& e) {
41272       {
41273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41274       };
41275     } catch (std::exception& e) {
41276       {
41277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41278       };
41279     } catch (...) {
41280       {
41281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41282       };
41283     }
41284   }
41285 }
41286
41287
41288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
41289   void * jresult ;
41290   Dali::FrameBufferImage *arg1 = 0 ;
41291   Dali::FrameBufferImage *result = 0 ;
41292
41293   arg1 = (Dali::FrameBufferImage *)jarg1;
41294   if (!arg1) {
41295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41296     return 0;
41297   }
41298   {
41299     try {
41300       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
41301     } catch (std::out_of_range& e) {
41302       {
41303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41304       };
41305     } catch (std::exception& e) {
41306       {
41307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41308       };
41309     } catch (...) {
41310       {
41311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41312       };
41313     }
41314   }
41315   jresult = (void *)result;
41316   return jresult;
41317 }
41318
41319
41320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
41321   void * jresult ;
41322   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41323   Dali::FrameBufferImage *arg2 = 0 ;
41324   Dali::FrameBufferImage *result = 0 ;
41325
41326   arg1 = (Dali::FrameBufferImage *)jarg1;
41327   arg2 = (Dali::FrameBufferImage *)jarg2;
41328   if (!arg2) {
41329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41330     return 0;
41331   }
41332   {
41333     try {
41334       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
41335     } catch (std::out_of_range& e) {
41336       {
41337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41338       };
41339     } catch (std::exception& e) {
41340       {
41341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41342       };
41343     } catch (...) {
41344       {
41345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41346       };
41347     }
41348   }
41349   jresult = (void *)result;
41350   return jresult;
41351 }
41352
41353
41354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
41355   void * jresult ;
41356   Dali::NinePatchImage *result = 0 ;
41357
41358   {
41359     try {
41360       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
41361     } catch (std::out_of_range& e) {
41362       {
41363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41364       };
41365     } catch (std::exception& e) {
41366       {
41367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41368       };
41369     } catch (...) {
41370       {
41371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41372       };
41373     }
41374   }
41375   jresult = (void *)result;
41376   return jresult;
41377 }
41378
41379
41380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
41381   void * jresult ;
41382   std::string *arg1 = 0 ;
41383   Dali::NinePatchImage result;
41384
41385   if (!jarg1) {
41386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41387     return 0;
41388   }
41389   std::string arg1_str(jarg1);
41390   arg1 = &arg1_str;
41391   {
41392     try {
41393       result = Dali::NinePatchImage::New((std::string const &)*arg1);
41394     } catch (std::out_of_range& e) {
41395       {
41396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41397       };
41398     } catch (std::exception& e) {
41399       {
41400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41401       };
41402     } catch (...) {
41403       {
41404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41405       };
41406     }
41407   }
41408   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41409
41410   //argout typemap for const std::string&
41411
41412   return jresult;
41413 }
41414
41415
41416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
41417   void * jresult ;
41418   Dali::BaseHandle arg1 ;
41419   Dali::BaseHandle *argp1 ;
41420   Dali::NinePatchImage result;
41421
41422   argp1 = (Dali::BaseHandle *)jarg1;
41423   if (!argp1) {
41424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41425     return 0;
41426   }
41427   arg1 = *argp1;
41428   {
41429     try {
41430       result = Dali::NinePatchImage::DownCast(arg1);
41431     } catch (std::out_of_range& e) {
41432       {
41433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41434       };
41435     } catch (std::exception& e) {
41436       {
41437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41438       };
41439     } catch (...) {
41440       {
41441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41442       };
41443     }
41444   }
41445   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41446   return jresult;
41447 }
41448
41449
41450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
41451   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41452
41453   arg1 = (Dali::NinePatchImage *)jarg1;
41454   {
41455     try {
41456       delete arg1;
41457     } catch (std::out_of_range& e) {
41458       {
41459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41460       };
41461     } catch (std::exception& e) {
41462       {
41463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41464       };
41465     } catch (...) {
41466       {
41467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41468       };
41469     }
41470   }
41471 }
41472
41473
41474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
41475   void * jresult ;
41476   Dali::NinePatchImage *arg1 = 0 ;
41477   Dali::NinePatchImage *result = 0 ;
41478
41479   arg1 = (Dali::NinePatchImage *)jarg1;
41480   if (!arg1) {
41481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41482     return 0;
41483   }
41484   {
41485     try {
41486       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
41487     } catch (std::out_of_range& e) {
41488       {
41489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41490       };
41491     } catch (std::exception& e) {
41492       {
41493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41494       };
41495     } catch (...) {
41496       {
41497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41498       };
41499     }
41500   }
41501   jresult = (void *)result;
41502   return jresult;
41503 }
41504
41505
41506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
41507   void * jresult ;
41508   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41509   Dali::NinePatchImage *arg2 = 0 ;
41510   Dali::NinePatchImage *result = 0 ;
41511
41512   arg1 = (Dali::NinePatchImage *)jarg1;
41513   arg2 = (Dali::NinePatchImage *)jarg2;
41514   if (!arg2) {
41515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41516     return 0;
41517   }
41518   {
41519     try {
41520       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
41521     } catch (std::out_of_range& e) {
41522       {
41523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41524       };
41525     } catch (std::exception& e) {
41526       {
41527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41528       };
41529     } catch (...) {
41530       {
41531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41532       };
41533     }
41534   }
41535   jresult = (void *)result;
41536   return jresult;
41537 }
41538
41539
41540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
41541   void * jresult ;
41542   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41543   Dali::Vector4 result;
41544
41545   arg1 = (Dali::NinePatchImage *)jarg1;
41546   {
41547     try {
41548       result = (arg1)->GetStretchBorders();
41549     } catch (std::out_of_range& e) {
41550       {
41551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41552       };
41553     } catch (std::exception& e) {
41554       {
41555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41556       };
41557     } catch (...) {
41558       {
41559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41560       };
41561     }
41562   }
41563   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41564   return jresult;
41565 }
41566
41567
41568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
41569   void * jresult ;
41570   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41571   Dali::NinePatchImage::StretchRanges *result = 0 ;
41572
41573   arg1 = (Dali::NinePatchImage *)jarg1;
41574   {
41575     try {
41576       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
41577     } catch (std::out_of_range& e) {
41578       {
41579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41580       };
41581     } catch (std::exception& e) {
41582       {
41583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41584       };
41585     } catch (...) {
41586       {
41587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41588       };
41589     }
41590   }
41591   jresult = (void *)result;
41592   return jresult;
41593 }
41594
41595
41596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
41597   void * jresult ;
41598   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41599   Dali::NinePatchImage::StretchRanges *result = 0 ;
41600
41601   arg1 = (Dali::NinePatchImage *)jarg1;
41602   {
41603     try {
41604       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
41605     } catch (std::out_of_range& e) {
41606       {
41607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41608       };
41609     } catch (std::exception& e) {
41610       {
41611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41612       };
41613     } catch (...) {
41614       {
41615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41616       };
41617     }
41618   }
41619   jresult = (void *)result;
41620   return jresult;
41621 }
41622
41623
41624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
41625   void * jresult ;
41626   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41627   Dali::Rect< int > result;
41628
41629   arg1 = (Dali::NinePatchImage *)jarg1;
41630   {
41631     try {
41632       result = (arg1)->GetChildRectangle();
41633     } catch (std::out_of_range& e) {
41634       {
41635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41636       };
41637     } catch (std::exception& e) {
41638       {
41639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41640       };
41641     } catch (...) {
41642       {
41643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41644       };
41645     }
41646   }
41647   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
41648   return jresult;
41649 }
41650
41651
41652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
41653   void * jresult ;
41654   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41655   Dali::BufferImage result;
41656
41657   arg1 = (Dali::NinePatchImage *)jarg1;
41658   {
41659     try {
41660       result = (arg1)->CreateCroppedBufferImage();
41661     } catch (std::out_of_range& e) {
41662       {
41663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41664       };
41665     } catch (std::exception& e) {
41666       {
41667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41668       };
41669     } catch (...) {
41670       {
41671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41672       };
41673     }
41674   }
41675   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41676   return jresult;
41677 }
41678
41679
41680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
41681   unsigned int jresult ;
41682   std::string *arg1 = 0 ;
41683   bool result;
41684
41685   if (!jarg1) {
41686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41687     return 0;
41688   }
41689   std::string arg1_str(jarg1);
41690   arg1 = &arg1_str;
41691   {
41692     try {
41693       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
41694     } catch (std::out_of_range& e) {
41695       {
41696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41697       };
41698     } catch (std::exception& e) {
41699       {
41700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41701       };
41702     } catch (...) {
41703       {
41704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41705       };
41706     }
41707   }
41708   jresult = result;
41709
41710   //argout typemap for const std::string&
41711
41712   return jresult;
41713 }
41714
41715
41716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
41717   int jresult ;
41718   int result;
41719
41720   result = (int)Dali::CameraActor::Property::TYPE;
41721   jresult = (int)result;
41722   return jresult;
41723 }
41724
41725
41726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
41727   int jresult ;
41728   int result;
41729
41730   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
41731   jresult = (int)result;
41732   return jresult;
41733 }
41734
41735
41736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
41737   int jresult ;
41738   int result;
41739
41740   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
41741   jresult = (int)result;
41742   return jresult;
41743 }
41744
41745
41746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
41747   int jresult ;
41748   int result;
41749
41750   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
41751   jresult = (int)result;
41752   return jresult;
41753 }
41754
41755
41756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
41757   int jresult ;
41758   int result;
41759
41760   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
41761   jresult = (int)result;
41762   return jresult;
41763 }
41764
41765
41766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
41767   int jresult ;
41768   int result;
41769
41770   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
41771   jresult = (int)result;
41772   return jresult;
41773 }
41774
41775
41776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
41777   int jresult ;
41778   int result;
41779
41780   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
41781   jresult = (int)result;
41782   return jresult;
41783 }
41784
41785
41786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
41787   int jresult ;
41788   int result;
41789
41790   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
41791   jresult = (int)result;
41792   return jresult;
41793 }
41794
41795
41796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
41797   int jresult ;
41798   int result;
41799
41800   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
41801   jresult = (int)result;
41802   return jresult;
41803 }
41804
41805
41806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
41807   int jresult ;
41808   int result;
41809
41810   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
41811   jresult = (int)result;
41812   return jresult;
41813 }
41814
41815
41816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
41817   int jresult ;
41818   int result;
41819
41820   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
41821   jresult = (int)result;
41822   return jresult;
41823 }
41824
41825
41826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
41827   int jresult ;
41828   int result;
41829
41830   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
41831   jresult = (int)result;
41832   return jresult;
41833 }
41834
41835
41836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
41837   int jresult ;
41838   int result;
41839
41840   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
41841   jresult = (int)result;
41842   return jresult;
41843 }
41844
41845
41846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
41847   int jresult ;
41848   int result;
41849
41850   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
41851   jresult = (int)result;
41852   return jresult;
41853 }
41854
41855
41856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
41857   void * jresult ;
41858   Dali::CameraActor::Property *result = 0 ;
41859
41860   {
41861     try {
41862       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
41863     } catch (std::out_of_range& e) {
41864       {
41865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41866       };
41867     } catch (std::exception& e) {
41868       {
41869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41870       };
41871     } catch (...) {
41872       {
41873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41874       };
41875     }
41876   }
41877   jresult = (void *)result;
41878   return jresult;
41879 }
41880
41881
41882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
41883   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
41884
41885   arg1 = (Dali::CameraActor::Property *)jarg1;
41886   {
41887     try {
41888       delete arg1;
41889     } catch (std::out_of_range& e) {
41890       {
41891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41892       };
41893     } catch (std::exception& e) {
41894       {
41895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41896       };
41897     } catch (...) {
41898       {
41899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41900       };
41901     }
41902   }
41903 }
41904
41905
41906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
41907   void * jresult ;
41908   Dali::CameraActor *result = 0 ;
41909
41910   {
41911     try {
41912       result = (Dali::CameraActor *)new Dali::CameraActor();
41913     } catch (std::out_of_range& e) {
41914       {
41915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41916       };
41917     } catch (std::exception& e) {
41918       {
41919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41920       };
41921     } catch (...) {
41922       {
41923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41924       };
41925     }
41926   }
41927   jresult = (void *)result;
41928   return jresult;
41929 }
41930
41931
41932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
41933   void * jresult ;
41934   Dali::CameraActor result;
41935
41936   {
41937     try {
41938       result = Dali::CameraActor::New();
41939     } catch (std::out_of_range& e) {
41940       {
41941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41942       };
41943     } catch (std::exception& e) {
41944       {
41945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41946       };
41947     } catch (...) {
41948       {
41949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41950       };
41951     }
41952   }
41953   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41954   return jresult;
41955 }
41956
41957
41958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
41959   void * jresult ;
41960   Dali::Size *arg1 = 0 ;
41961   Dali::CameraActor result;
41962
41963   arg1 = (Dali::Size *)jarg1;
41964   if (!arg1) {
41965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
41966     return 0;
41967   }
41968   {
41969     try {
41970       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
41971     } catch (std::out_of_range& e) {
41972       {
41973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41974       };
41975     } catch (std::exception& e) {
41976       {
41977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41978       };
41979     } catch (...) {
41980       {
41981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41982       };
41983     }
41984   }
41985   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41986   return jresult;
41987 }
41988
41989
41990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
41991   void * jresult ;
41992   Dali::BaseHandle arg1 ;
41993   Dali::BaseHandle *argp1 ;
41994   Dali::CameraActor result;
41995
41996   argp1 = (Dali::BaseHandle *)jarg1;
41997   if (!argp1) {
41998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41999     return 0;
42000   }
42001   arg1 = *argp1;
42002   {
42003     try {
42004       result = Dali::CameraActor::DownCast(arg1);
42005     } catch (std::out_of_range& e) {
42006       {
42007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42008       };
42009     } catch (std::exception& e) {
42010       {
42011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42012       };
42013     } catch (...) {
42014       {
42015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42016       };
42017     }
42018   }
42019   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
42020   return jresult;
42021 }
42022
42023
42024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
42025   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42026
42027   arg1 = (Dali::CameraActor *)jarg1;
42028   {
42029     try {
42030       delete arg1;
42031     } catch (std::out_of_range& e) {
42032       {
42033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42034       };
42035     } catch (std::exception& e) {
42036       {
42037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42038       };
42039     } catch (...) {
42040       {
42041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42042       };
42043     }
42044   }
42045 }
42046
42047
42048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
42049   void * jresult ;
42050   Dali::CameraActor *arg1 = 0 ;
42051   Dali::CameraActor *result = 0 ;
42052
42053   arg1 = (Dali::CameraActor *)jarg1;
42054   if (!arg1) {
42055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42056     return 0;
42057   }
42058   {
42059     try {
42060       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
42061     } catch (std::out_of_range& e) {
42062       {
42063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42064       };
42065     } catch (std::exception& e) {
42066       {
42067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42068       };
42069     } catch (...) {
42070       {
42071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42072       };
42073     }
42074   }
42075   jresult = (void *)result;
42076   return jresult;
42077 }
42078
42079
42080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
42081   void * jresult ;
42082   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42083   Dali::CameraActor *arg2 = 0 ;
42084   Dali::CameraActor *result = 0 ;
42085
42086   arg1 = (Dali::CameraActor *)jarg1;
42087   arg2 = (Dali::CameraActor *)jarg2;
42088   if (!arg2) {
42089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42090     return 0;
42091   }
42092   {
42093     try {
42094       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
42095     } catch (std::out_of_range& e) {
42096       {
42097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42098       };
42099     } catch (std::exception& e) {
42100       {
42101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42102       };
42103     } catch (...) {
42104       {
42105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42106       };
42107     }
42108   }
42109   jresult = (void *)result;
42110   return jresult;
42111 }
42112
42113
42114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
42115   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42116   Dali::Camera::Type arg2 ;
42117
42118   arg1 = (Dali::CameraActor *)jarg1;
42119   arg2 = (Dali::Camera::Type)jarg2;
42120   {
42121     try {
42122       (arg1)->SetType(arg2);
42123     } catch (std::out_of_range& e) {
42124       {
42125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42126       };
42127     } catch (std::exception& e) {
42128       {
42129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42130       };
42131     } catch (...) {
42132       {
42133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42134       };
42135     }
42136   }
42137 }
42138
42139
42140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
42141   int jresult ;
42142   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42143   Dali::Camera::Type result;
42144
42145   arg1 = (Dali::CameraActor *)jarg1;
42146   {
42147     try {
42148       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
42149     } catch (std::out_of_range& e) {
42150       {
42151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42152       };
42153     } catch (std::exception& e) {
42154       {
42155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42156       };
42157     } catch (...) {
42158       {
42159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42160       };
42161     }
42162   }
42163   jresult = (int)result;
42164   return jresult;
42165 }
42166
42167
42168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
42169   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42170   Dali::Camera::ProjectionMode arg2 ;
42171
42172   arg1 = (Dali::CameraActor *)jarg1;
42173   arg2 = (Dali::Camera::ProjectionMode)jarg2;
42174   {
42175     try {
42176       (arg1)->SetProjectionMode(arg2);
42177     } catch (std::out_of_range& e) {
42178       {
42179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42180       };
42181     } catch (std::exception& e) {
42182       {
42183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42184       };
42185     } catch (...) {
42186       {
42187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42188       };
42189     }
42190   }
42191 }
42192
42193
42194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
42195   int jresult ;
42196   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42197   Dali::Camera::ProjectionMode result;
42198
42199   arg1 = (Dali::CameraActor *)jarg1;
42200   {
42201     try {
42202       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
42203     } catch (std::out_of_range& e) {
42204       {
42205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42206       };
42207     } catch (std::exception& e) {
42208       {
42209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42210       };
42211     } catch (...) {
42212       {
42213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42214       };
42215     }
42216   }
42217   jresult = (int)result;
42218   return jresult;
42219 }
42220
42221
42222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
42223   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42224   float arg2 ;
42225
42226   arg1 = (Dali::CameraActor *)jarg1;
42227   arg2 = (float)jarg2;
42228   {
42229     try {
42230       (arg1)->SetFieldOfView(arg2);
42231     } catch (std::out_of_range& e) {
42232       {
42233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42234       };
42235     } catch (std::exception& e) {
42236       {
42237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42238       };
42239     } catch (...) {
42240       {
42241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42242       };
42243     }
42244   }
42245 }
42246
42247
42248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
42249   float jresult ;
42250   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42251   float result;
42252
42253   arg1 = (Dali::CameraActor *)jarg1;
42254   {
42255     try {
42256       result = (float)(arg1)->GetFieldOfView();
42257     } catch (std::out_of_range& e) {
42258       {
42259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42260       };
42261     } catch (std::exception& e) {
42262       {
42263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42264       };
42265     } catch (...) {
42266       {
42267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42268       };
42269     }
42270   }
42271   jresult = result;
42272   return jresult;
42273 }
42274
42275
42276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
42277   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42278   float arg2 ;
42279
42280   arg1 = (Dali::CameraActor *)jarg1;
42281   arg2 = (float)jarg2;
42282   {
42283     try {
42284       (arg1)->SetAspectRatio(arg2);
42285     } catch (std::out_of_range& e) {
42286       {
42287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42288       };
42289     } catch (std::exception& e) {
42290       {
42291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42292       };
42293     } catch (...) {
42294       {
42295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42296       };
42297     }
42298   }
42299 }
42300
42301
42302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
42303   float jresult ;
42304   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42305   float result;
42306
42307   arg1 = (Dali::CameraActor *)jarg1;
42308   {
42309     try {
42310       result = (float)(arg1)->GetAspectRatio();
42311     } catch (std::out_of_range& e) {
42312       {
42313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42314       };
42315     } catch (std::exception& e) {
42316       {
42317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42318       };
42319     } catch (...) {
42320       {
42321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42322       };
42323     }
42324   }
42325   jresult = result;
42326   return jresult;
42327 }
42328
42329
42330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
42331   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42332   float arg2 ;
42333
42334   arg1 = (Dali::CameraActor *)jarg1;
42335   arg2 = (float)jarg2;
42336   {
42337     try {
42338       (arg1)->SetNearClippingPlane(arg2);
42339     } catch (std::out_of_range& e) {
42340       {
42341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42342       };
42343     } catch (std::exception& e) {
42344       {
42345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42346       };
42347     } catch (...) {
42348       {
42349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42350       };
42351     }
42352   }
42353 }
42354
42355
42356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
42357   float jresult ;
42358   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42359   float result;
42360
42361   arg1 = (Dali::CameraActor *)jarg1;
42362   {
42363     try {
42364       result = (float)(arg1)->GetNearClippingPlane();
42365     } catch (std::out_of_range& e) {
42366       {
42367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42368       };
42369     } catch (std::exception& e) {
42370       {
42371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42372       };
42373     } catch (...) {
42374       {
42375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42376       };
42377     }
42378   }
42379   jresult = result;
42380   return jresult;
42381 }
42382
42383
42384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
42385   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42386   float arg2 ;
42387
42388   arg1 = (Dali::CameraActor *)jarg1;
42389   arg2 = (float)jarg2;
42390   {
42391     try {
42392       (arg1)->SetFarClippingPlane(arg2);
42393     } catch (std::out_of_range& e) {
42394       {
42395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42396       };
42397     } catch (std::exception& e) {
42398       {
42399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42400       };
42401     } catch (...) {
42402       {
42403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42404       };
42405     }
42406   }
42407 }
42408
42409
42410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
42411   float jresult ;
42412   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42413   float result;
42414
42415   arg1 = (Dali::CameraActor *)jarg1;
42416   {
42417     try {
42418       result = (float)(arg1)->GetFarClippingPlane();
42419     } catch (std::out_of_range& e) {
42420       {
42421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42422       };
42423     } catch (std::exception& e) {
42424       {
42425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42426       };
42427     } catch (...) {
42428       {
42429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42430       };
42431     }
42432   }
42433   jresult = result;
42434   return jresult;
42435 }
42436
42437
42438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
42439   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42440   Dali::Vector3 *arg2 = 0 ;
42441
42442   arg1 = (Dali::CameraActor *)jarg1;
42443   arg2 = (Dali::Vector3 *)jarg2;
42444   if (!arg2) {
42445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42446     return ;
42447   }
42448   {
42449     try {
42450       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
42451     } catch (std::out_of_range& e) {
42452       {
42453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42454       };
42455     } catch (std::exception& e) {
42456       {
42457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42458       };
42459     } catch (...) {
42460       {
42461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42462       };
42463     }
42464   }
42465 }
42466
42467
42468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
42469   void * jresult ;
42470   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42471   Dali::Vector3 result;
42472
42473   arg1 = (Dali::CameraActor *)jarg1;
42474   {
42475     try {
42476       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
42477     } catch (std::out_of_range& e) {
42478       {
42479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42480       };
42481     } catch (std::exception& e) {
42482       {
42483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42484       };
42485     } catch (...) {
42486       {
42487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42488       };
42489     }
42490   }
42491   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42492   return jresult;
42493 }
42494
42495
42496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
42497   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42498   bool arg2 ;
42499
42500   arg1 = (Dali::CameraActor *)jarg1;
42501   arg2 = jarg2 ? true : false;
42502   {
42503     try {
42504       (arg1)->SetInvertYAxis(arg2);
42505     } catch (std::out_of_range& e) {
42506       {
42507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42508       };
42509     } catch (std::exception& e) {
42510       {
42511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42512       };
42513     } catch (...) {
42514       {
42515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42516       };
42517     }
42518   }
42519 }
42520
42521
42522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
42523   unsigned int jresult ;
42524   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42525   bool result;
42526
42527   arg1 = (Dali::CameraActor *)jarg1;
42528   {
42529     try {
42530       result = (bool)(arg1)->GetInvertYAxis();
42531     } catch (std::out_of_range& e) {
42532       {
42533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42534       };
42535     } catch (std::exception& e) {
42536       {
42537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42538       };
42539     } catch (...) {
42540       {
42541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42542       };
42543     }
42544   }
42545   jresult = result;
42546   return jresult;
42547 }
42548
42549
42550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
42551   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42552   Dali::Size *arg2 = 0 ;
42553
42554   arg1 = (Dali::CameraActor *)jarg1;
42555   arg2 = (Dali::Size *)jarg2;
42556   if (!arg2) {
42557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42558     return ;
42559   }
42560   {
42561     try {
42562       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
42563     } catch (std::out_of_range& e) {
42564       {
42565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42566       };
42567     } catch (std::exception& e) {
42568       {
42569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42570       };
42571     } catch (...) {
42572       {
42573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42574       };
42575     }
42576   }
42577 }
42578
42579
42580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
42581   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42582   Dali::Size *arg2 = 0 ;
42583
42584   arg1 = (Dali::CameraActor *)jarg1;
42585   arg2 = (Dali::Size *)jarg2;
42586   if (!arg2) {
42587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42588     return ;
42589   }
42590   {
42591     try {
42592       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
42593     } catch (std::out_of_range& e) {
42594       {
42595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42596       };
42597     } catch (std::exception& e) {
42598       {
42599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42600       };
42601     } catch (...) {
42602       {
42603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42604       };
42605     }
42606   }
42607 }
42608
42609
42610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
42611   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42612   float arg2 ;
42613   float arg3 ;
42614   float arg4 ;
42615   float arg5 ;
42616   float arg6 ;
42617   float arg7 ;
42618
42619   arg1 = (Dali::CameraActor *)jarg1;
42620   arg2 = (float)jarg2;
42621   arg3 = (float)jarg3;
42622   arg4 = (float)jarg4;
42623   arg5 = (float)jarg5;
42624   arg6 = (float)jarg6;
42625   arg7 = (float)jarg7;
42626   {
42627     try {
42628       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
42629     } catch (std::out_of_range& e) {
42630       {
42631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42632       };
42633     } catch (std::exception& e) {
42634       {
42635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42636       };
42637     } catch (...) {
42638       {
42639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42640       };
42641     }
42642   }
42643 }
42644
42645
42646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
42647   void * jresult ;
42648   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42649
42650   {
42651     try {
42652       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
42653     } catch (std::out_of_range& e) {
42654       {
42655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42656       };
42657     } catch (std::exception& e) {
42658       {
42659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42660       };
42661     } catch (...) {
42662       {
42663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42664       };
42665     }
42666   }
42667   jresult = (void *)result;
42668   return jresult;
42669 }
42670
42671
42672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
42673   void * jresult ;
42674   std::string arg1 ;
42675   Dali::Property::Value arg2 ;
42676   Dali::Property::Value *argp2 ;
42677   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42678
42679   if (!jarg1) {
42680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42681     return 0;
42682   }
42683   (&arg1)->assign(jarg1);
42684   argp2 = (Dali::Property::Value *)jarg2;
42685   if (!argp2) {
42686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42687     return 0;
42688   }
42689   arg2 = *argp2;
42690   {
42691     try {
42692       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
42693     } catch (std::out_of_range& e) {
42694       {
42695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42696       };
42697     } catch (std::exception& e) {
42698       {
42699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42700       };
42701     } catch (...) {
42702       {
42703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42704       };
42705     }
42706   }
42707   jresult = (void *)result;
42708   return jresult;
42709 }
42710
42711
42712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
42713   void * jresult ;
42714   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
42715   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42716
42717   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42718   if (!arg1) {
42719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
42720     return 0;
42721   }
42722   {
42723     try {
42724       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >((std::pair< std::string,Dali::Property::Value > const &)*arg1);
42725     } catch (std::out_of_range& e) {
42726       {
42727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42728       };
42729     } catch (std::exception& e) {
42730       {
42731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42732       };
42733     } catch (...) {
42734       {
42735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42736       };
42737     }
42738   }
42739   jresult = (void *)result;
42740   return jresult;
42741 }
42742
42743
42744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
42745   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42746   std::string *arg2 = 0 ;
42747
42748   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42749   if (!jarg2) {
42750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42751     return ;
42752   }
42753   std::string arg2_str(jarg2);
42754   arg2 = &arg2_str;
42755   if (arg1) (arg1)->first = *arg2;
42756
42757   //argout typemap for const std::string&
42758
42759 }
42760
42761
42762 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
42763   char * jresult ;
42764   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42765   std::string *result = 0 ;
42766
42767   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42768   result = (std::string *) & ((arg1)->first);
42769   jresult = SWIG_csharp_string_callback(result->c_str());
42770   return jresult;
42771 }
42772
42773
42774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
42775   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42776   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
42777
42778   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42779   arg2 = (Dali::Property::Value *)jarg2;
42780   if (arg1) (arg1)->second = *arg2;
42781 }
42782
42783
42784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
42785   void * jresult ;
42786   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42787   Dali::Property::Value *result = 0 ;
42788
42789   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42790   result = (Dali::Property::Value *)& ((arg1)->second);
42791   jresult = (void *)result;
42792   return jresult;
42793 }
42794
42795
42796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
42797   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42798
42799   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42800   {
42801     try {
42802       delete arg1;
42803     } catch (std::out_of_range& e) {
42804       {
42805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42806       };
42807     } catch (std::exception& e) {
42808       {
42809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42810       };
42811     } catch (...) {
42812       {
42813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42814       };
42815     }
42816   }
42817 }
42818
42819
42820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
42821   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42822
42823   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42824   {
42825     try {
42826       (arg1)->clear();
42827     } catch (std::out_of_range& e) {
42828       {
42829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42830       };
42831     } catch (std::exception& e) {
42832       {
42833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42834       };
42835     } catch (...) {
42836       {
42837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42838       };
42839     }
42840   }
42841 }
42842
42843
42844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
42845   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42846   Dali::TouchPoint *arg2 = 0 ;
42847
42848   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42849   arg2 = (Dali::TouchPoint *)jarg2;
42850   if (!arg2) {
42851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
42852     return ;
42853   }
42854   {
42855     try {
42856       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
42857     } catch (std::out_of_range& e) {
42858       {
42859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42860       };
42861     } catch (std::exception& e) {
42862       {
42863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42864       };
42865     } catch (...) {
42866       {
42867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42868       };
42869     }
42870   }
42871 }
42872
42873
42874 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
42875   unsigned long jresult ;
42876   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42877   std::vector< Dali::TouchPoint >::size_type result;
42878
42879   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42880   {
42881     try {
42882       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
42883     } catch (std::out_of_range& e) {
42884       {
42885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42886       };
42887     } catch (std::exception& e) {
42888       {
42889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42890       };
42891     } catch (...) {
42892       {
42893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42894       };
42895     }
42896   }
42897   jresult = (unsigned long)result;
42898   return jresult;
42899 }
42900
42901
42902 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
42903   unsigned long jresult ;
42904   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42905   std::vector< Dali::TouchPoint >::size_type result;
42906
42907   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42908   {
42909     try {
42910       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
42911     } catch (std::out_of_range& e) {
42912       {
42913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42914       };
42915     } catch (std::exception& e) {
42916       {
42917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42918       };
42919     } catch (...) {
42920       {
42921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42922       };
42923     }
42924   }
42925   jresult = (unsigned long)result;
42926   return jresult;
42927 }
42928
42929
42930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
42931   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42932   std::vector< Dali::TouchPoint >::size_type arg2 ;
42933
42934   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42935   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
42936   {
42937     try {
42938       (arg1)->reserve(arg2);
42939     } catch (std::out_of_range& e) {
42940       {
42941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42942       };
42943     } catch (std::exception& e) {
42944       {
42945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42946       };
42947     } catch (...) {
42948       {
42949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42950       };
42951     }
42952   }
42953 }
42954
42955
42956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
42957   void * jresult ;
42958   std::vector< Dali::TouchPoint > *result = 0 ;
42959
42960   {
42961     try {
42962       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
42963     } catch (std::out_of_range& e) {
42964       {
42965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42966       };
42967     } catch (std::exception& e) {
42968       {
42969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42970       };
42971     } catch (...) {
42972       {
42973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42974       };
42975     }
42976   }
42977   jresult = (void *)result;
42978   return jresult;
42979 }
42980
42981
42982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
42983   void * jresult ;
42984   std::vector< Dali::TouchPoint > *arg1 = 0 ;
42985   std::vector< Dali::TouchPoint > *result = 0 ;
42986
42987   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42988   if (!arg1) {
42989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
42990     return 0;
42991   }
42992   {
42993     try {
42994       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
42995     } catch (std::out_of_range& e) {
42996       {
42997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42998       };
42999     } catch (std::exception& e) {
43000       {
43001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43002       };
43003     } catch (...) {
43004       {
43005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43006       };
43007     }
43008   }
43009   jresult = (void *)result;
43010   return jresult;
43011 }
43012
43013
43014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
43015   void * jresult ;
43016   int arg1 ;
43017   std::vector< Dali::TouchPoint > *result = 0 ;
43018
43019   arg1 = (int)jarg1;
43020   {
43021     try {
43022       try {
43023         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
43024       }
43025       catch(std::out_of_range &_e) {
43026         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43027         return 0;
43028       }
43029
43030     } catch (std::out_of_range& e) {
43031       {
43032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43033       };
43034     } catch (std::exception& e) {
43035       {
43036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43037       };
43038     } catch (...) {
43039       {
43040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43041       };
43042     }
43043   }
43044   jresult = (void *)result;
43045   return jresult;
43046 }
43047
43048
43049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
43050   void * jresult ;
43051   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43052   int arg2 ;
43053   SwigValueWrapper< Dali::TouchPoint > result;
43054
43055   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43056   arg2 = (int)jarg2;
43057   {
43058     try {
43059       try {
43060         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
43061       }
43062       catch(std::out_of_range &_e) {
43063         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43064         return 0;
43065       }
43066
43067     } catch (std::out_of_range& e) {
43068       {
43069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43070       };
43071     } catch (std::exception& e) {
43072       {
43073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43074       };
43075     } catch (...) {
43076       {
43077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43078       };
43079     }
43080   }
43081   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
43082   return jresult;
43083 }
43084
43085
43086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
43087   void * jresult ;
43088   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43089   int arg2 ;
43090   Dali::TouchPoint *result = 0 ;
43091
43092   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43093   arg2 = (int)jarg2;
43094   {
43095     try {
43096       try {
43097         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
43098       }
43099       catch(std::out_of_range &_e) {
43100         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43101         return 0;
43102       }
43103
43104     } catch (std::out_of_range& e) {
43105       {
43106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43107       };
43108     } catch (std::exception& e) {
43109       {
43110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43111       };
43112     } catch (...) {
43113       {
43114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43115       };
43116     }
43117   }
43118   jresult = (void *)result;
43119   return jresult;
43120 }
43121
43122
43123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
43124   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43125   int arg2 ;
43126   Dali::TouchPoint *arg3 = 0 ;
43127
43128   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43129   arg2 = (int)jarg2;
43130   arg3 = (Dali::TouchPoint *)jarg3;
43131   if (!arg3) {
43132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43133     return ;
43134   }
43135   {
43136     try {
43137       try {
43138         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43139       }
43140       catch(std::out_of_range &_e) {
43141         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43142         return ;
43143       }
43144
43145     } catch (std::out_of_range& e) {
43146       {
43147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43148       };
43149     } catch (std::exception& e) {
43150       {
43151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43152       };
43153     } catch (...) {
43154       {
43155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43156       };
43157     }
43158   }
43159 }
43160
43161
43162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
43163   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43164   std::vector< Dali::TouchPoint > *arg2 = 0 ;
43165
43166   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43167   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
43168   if (!arg2) {
43169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43170     return ;
43171   }
43172   {
43173     try {
43174       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
43175     } catch (std::out_of_range& e) {
43176       {
43177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43178       };
43179     } catch (std::exception& e) {
43180       {
43181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43182       };
43183     } catch (...) {
43184       {
43185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43186       };
43187     }
43188   }
43189 }
43190
43191
43192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
43193   void * jresult ;
43194   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43195   int arg2 ;
43196   int arg3 ;
43197   std::vector< Dali::TouchPoint > *result = 0 ;
43198
43199   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43200   arg2 = (int)jarg2;
43201   arg3 = (int)jarg3;
43202   {
43203     try {
43204       try {
43205         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
43206       }
43207       catch(std::out_of_range &_e) {
43208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43209         return 0;
43210       }
43211       catch(std::invalid_argument &_e) {
43212         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43213         return 0;
43214       }
43215
43216     } catch (std::out_of_range& e) {
43217       {
43218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43219       };
43220     } catch (std::exception& e) {
43221       {
43222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43223       };
43224     } catch (...) {
43225       {
43226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43227       };
43228     }
43229   }
43230   jresult = (void *)result;
43231   return jresult;
43232 }
43233
43234
43235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
43236   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43237   int arg2 ;
43238   Dali::TouchPoint *arg3 = 0 ;
43239
43240   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43241   arg2 = (int)jarg2;
43242   arg3 = (Dali::TouchPoint *)jarg3;
43243   if (!arg3) {
43244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43245     return ;
43246   }
43247   {
43248     try {
43249       try {
43250         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43251       }
43252       catch(std::out_of_range &_e) {
43253         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43254         return ;
43255       }
43256
43257     } catch (std::out_of_range& e) {
43258       {
43259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43260       };
43261     } catch (std::exception& e) {
43262       {
43263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43264       };
43265     } catch (...) {
43266       {
43267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43268       };
43269     }
43270   }
43271 }
43272
43273
43274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
43275   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43276   int arg2 ;
43277   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43278
43279   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43280   arg2 = (int)jarg2;
43281   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43282   if (!arg3) {
43283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43284     return ;
43285   }
43286   {
43287     try {
43288       try {
43289         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43290       }
43291       catch(std::out_of_range &_e) {
43292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43293         return ;
43294       }
43295
43296     } catch (std::out_of_range& e) {
43297       {
43298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43299       };
43300     } catch (std::exception& e) {
43301       {
43302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43303       };
43304     } catch (...) {
43305       {
43306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43307       };
43308     }
43309   }
43310 }
43311
43312
43313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
43314   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43315   int arg2 ;
43316
43317   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43318   arg2 = (int)jarg2;
43319   {
43320     try {
43321       try {
43322         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
43323       }
43324       catch(std::out_of_range &_e) {
43325         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43326         return ;
43327       }
43328
43329     } catch (std::out_of_range& e) {
43330       {
43331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43332       };
43333     } catch (std::exception& e) {
43334       {
43335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43336       };
43337     } catch (...) {
43338       {
43339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43340       };
43341     }
43342   }
43343 }
43344
43345
43346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
43347   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43348   int arg2 ;
43349   int arg3 ;
43350
43351   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43352   arg2 = (int)jarg2;
43353   arg3 = (int)jarg3;
43354   {
43355     try {
43356       try {
43357         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
43358       }
43359       catch(std::out_of_range &_e) {
43360         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43361         return ;
43362       }
43363       catch(std::invalid_argument &_e) {
43364         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43365         return ;
43366       }
43367
43368     } catch (std::out_of_range& e) {
43369       {
43370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43371       };
43372     } catch (std::exception& e) {
43373       {
43374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43375       };
43376     } catch (...) {
43377       {
43378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43379       };
43380     }
43381   }
43382 }
43383
43384
43385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
43386   void * jresult ;
43387   Dali::TouchPoint *arg1 = 0 ;
43388   int arg2 ;
43389   std::vector< Dali::TouchPoint > *result = 0 ;
43390
43391   arg1 = (Dali::TouchPoint *)jarg1;
43392   if (!arg1) {
43393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43394     return 0;
43395   }
43396   arg2 = (int)jarg2;
43397   {
43398     try {
43399       try {
43400         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
43401       }
43402       catch(std::out_of_range &_e) {
43403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43404         return 0;
43405       }
43406
43407     } catch (std::out_of_range& e) {
43408       {
43409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43410       };
43411     } catch (std::exception& e) {
43412       {
43413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43414       };
43415     } catch (...) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43418       };
43419     }
43420   }
43421   jresult = (void *)result;
43422   return jresult;
43423 }
43424
43425
43426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
43427   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43428
43429   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43430   {
43431     try {
43432       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
43433     } catch (std::out_of_range& e) {
43434       {
43435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43436       };
43437     } catch (std::exception& e) {
43438       {
43439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43440       };
43441     } catch (...) {
43442       {
43443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43444       };
43445     }
43446   }
43447 }
43448
43449
43450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
43451   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43452   int arg2 ;
43453   int arg3 ;
43454
43455   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43456   arg2 = (int)jarg2;
43457   arg3 = (int)jarg3;
43458   {
43459     try {
43460       try {
43461         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
43462       }
43463       catch(std::out_of_range &_e) {
43464         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43465         return ;
43466       }
43467       catch(std::invalid_argument &_e) {
43468         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43469         return ;
43470       }
43471
43472     } catch (std::out_of_range& e) {
43473       {
43474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43475       };
43476     } catch (std::exception& e) {
43477       {
43478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43479       };
43480     } catch (...) {
43481       {
43482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43483       };
43484     }
43485   }
43486 }
43487
43488
43489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
43490   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43491   int arg2 ;
43492   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43493
43494   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43495   arg2 = (int)jarg2;
43496   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43497   if (!arg3) {
43498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43499     return ;
43500   }
43501   {
43502     try {
43503       try {
43504         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43505       }
43506       catch(std::out_of_range &_e) {
43507         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43508         return ;
43509       }
43510
43511     } catch (std::out_of_range& e) {
43512       {
43513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43514       };
43515     } catch (std::exception& e) {
43516       {
43517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43518       };
43519     } catch (...) {
43520       {
43521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43522       };
43523     }
43524   }
43525 }
43526
43527
43528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
43529   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43530
43531   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43532   {
43533     try {
43534       delete arg1;
43535     } catch (std::out_of_range& e) {
43536       {
43537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43538       };
43539     } catch (std::exception& e) {
43540       {
43541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43542       };
43543     } catch (...) {
43544       {
43545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43546       };
43547     }
43548   }
43549 }
43550
43551
43552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectDouble__SWIG_0() {
43553   void * jresult ;
43554   Dali::Rect< double > *result = 0 ;
43555
43556   {
43557     try {
43558       result = (Dali::Rect< double > *)new Dali::Rect< double >();
43559     } catch (std::out_of_range& e) {
43560       {
43561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43562       };
43563     } catch (std::exception& e) {
43564       {
43565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43566       };
43567     } catch (...) {
43568       {
43569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43570       };
43571     }
43572   }
43573   jresult = (void *)result;
43574   return jresult;
43575 }
43576
43577
43578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectDouble__SWIG_1(double jarg1, double jarg2, double jarg3, double jarg4) {
43579   void * jresult ;
43580   double arg1 ;
43581   double arg2 ;
43582   double arg3 ;
43583   double arg4 ;
43584   Dali::Rect< double > *result = 0 ;
43585
43586   arg1 = (double)jarg1;
43587   arg2 = (double)jarg2;
43588   arg3 = (double)jarg3;
43589   arg4 = (double)jarg4;
43590   {
43591     try {
43592       result = (Dali::Rect< double > *)new Dali::Rect< double >(arg1,arg2,arg3,arg4);
43593     } catch (std::out_of_range& e) {
43594       {
43595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43596       };
43597     } catch (std::exception& e) {
43598       {
43599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43600       };
43601     } catch (...) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43604       };
43605     }
43606   }
43607   jresult = (void *)result;
43608   return jresult;
43609 }
43610
43611
43612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectDouble__SWIG_2(void * jarg1) {
43613   void * jresult ;
43614   Dali::Rect< double > *arg1 = 0 ;
43615   Dali::Rect< double > *result = 0 ;
43616
43617   arg1 = (Dali::Rect< double > *)jarg1;
43618   if (!arg1) {
43619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
43620     return 0;
43621   }
43622   {
43623     try {
43624       result = (Dali::Rect< double > *)new Dali::Rect< double >((Dali::Rect< double > const &)*arg1);
43625     } catch (std::out_of_range& e) {
43626       {
43627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43628       };
43629     } catch (std::exception& e) {
43630       {
43631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43632       };
43633     } catch (...) {
43634       {
43635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43636       };
43637     }
43638   }
43639   jresult = (void *)result;
43640   return jresult;
43641 }
43642
43643
43644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RectDouble_Assign(void * jarg1, void * jarg2) {
43645   void * jresult ;
43646   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43647   Dali::Rect< double > *arg2 = 0 ;
43648   Dali::Rect< double > *result = 0 ;
43649
43650   arg1 = (Dali::Rect< double > *)jarg1;
43651   arg2 = (Dali::Rect< double > *)jarg2;
43652   if (!arg2) {
43653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
43654     return 0;
43655   }
43656   {
43657     try {
43658       result = (Dali::Rect< double > *) &(arg1)->operator =((Dali::Rect< double > const &)*arg2);
43659     } catch (std::out_of_range& e) {
43660       {
43661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43662       };
43663     } catch (std::exception& e) {
43664       {
43665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43666       };
43667     } catch (...) {
43668       {
43669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43670       };
43671     }
43672   }
43673   jresult = (void *)result;
43674   return jresult;
43675 }
43676
43677
43678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_Set(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
43679   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43680   double arg2 ;
43681   double arg3 ;
43682   double arg4 ;
43683   double arg5 ;
43684
43685   arg1 = (Dali::Rect< double > *)jarg1;
43686   arg2 = (double)jarg2;
43687   arg3 = (double)jarg3;
43688   arg4 = (double)jarg4;
43689   arg5 = (double)jarg5;
43690   {
43691     try {
43692       (arg1)->Set(arg2,arg3,arg4,arg5);
43693     } catch (std::out_of_range& e) {
43694       {
43695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43696       };
43697     } catch (std::exception& e) {
43698       {
43699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43700       };
43701     } catch (...) {
43702       {
43703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43704       };
43705     }
43706   }
43707 }
43708
43709
43710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectDouble_IsEmpty(void * jarg1) {
43711   unsigned int jresult ;
43712   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43713   bool result;
43714
43715   arg1 = (Dali::Rect< double > *)jarg1;
43716   {
43717     try {
43718       result = (bool)((Dali::Rect< double > const *)arg1)->IsEmpty();
43719     } catch (std::out_of_range& e) {
43720       {
43721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43722       };
43723     } catch (std::exception& e) {
43724       {
43725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43726       };
43727     } catch (...) {
43728       {
43729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43730       };
43731     }
43732   }
43733   jresult = result;
43734   return jresult;
43735 }
43736
43737
43738 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Left(void * jarg1) {
43739   double jresult ;
43740   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43741   double result;
43742
43743   arg1 = (Dali::Rect< double > *)jarg1;
43744   {
43745     try {
43746       result = (double)((Dali::Rect< double > const *)arg1)->Left();
43747     } catch (std::out_of_range& e) {
43748       {
43749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43750       };
43751     } catch (std::exception& e) {
43752       {
43753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43754       };
43755     } catch (...) {
43756       {
43757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43758       };
43759     }
43760   }
43761   jresult = result;
43762   return jresult;
43763 }
43764
43765
43766 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Right(void * jarg1) {
43767   double jresult ;
43768   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43769   double result;
43770
43771   arg1 = (Dali::Rect< double > *)jarg1;
43772   {
43773     try {
43774       result = (double)((Dali::Rect< double > const *)arg1)->Right();
43775     } catch (std::out_of_range& e) {
43776       {
43777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43778       };
43779     } catch (std::exception& e) {
43780       {
43781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43782       };
43783     } catch (...) {
43784       {
43785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43786       };
43787     }
43788   }
43789   jresult = result;
43790   return jresult;
43791 }
43792
43793
43794 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Top(void * jarg1) {
43795   double jresult ;
43796   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43797   double result;
43798
43799   arg1 = (Dali::Rect< double > *)jarg1;
43800   {
43801     try {
43802       result = (double)((Dali::Rect< double > const *)arg1)->Top();
43803     } catch (std::out_of_range& e) {
43804       {
43805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43806       };
43807     } catch (std::exception& e) {
43808       {
43809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43810       };
43811     } catch (...) {
43812       {
43813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43814       };
43815     }
43816   }
43817   jresult = result;
43818   return jresult;
43819 }
43820
43821
43822 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Bottom(void * jarg1) {
43823   double jresult ;
43824   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43825   double result;
43826
43827   arg1 = (Dali::Rect< double > *)jarg1;
43828   {
43829     try {
43830       result = (double)((Dali::Rect< double > const *)arg1)->Bottom();
43831     } catch (std::out_of_range& e) {
43832       {
43833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43834       };
43835     } catch (std::exception& e) {
43836       {
43837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43838       };
43839     } catch (...) {
43840       {
43841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43842       };
43843     }
43844   }
43845   jresult = result;
43846   return jresult;
43847 }
43848
43849
43850 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Area(void * jarg1) {
43851   double jresult ;
43852   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43853   double result;
43854
43855   arg1 = (Dali::Rect< double > *)jarg1;
43856   {
43857     try {
43858       result = (double)((Dali::Rect< double > const *)arg1)->Area();
43859     } catch (std::out_of_range& e) {
43860       {
43861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43862       };
43863     } catch (std::exception& e) {
43864       {
43865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43866       };
43867     } catch (...) {
43868       {
43869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43870       };
43871     }
43872   }
43873   jresult = result;
43874   return jresult;
43875 }
43876
43877
43878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectDouble_Intersects(void * jarg1, void * jarg2) {
43879   unsigned int jresult ;
43880   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43881   Dali::Rect< double > *arg2 = 0 ;
43882   bool result;
43883
43884   arg1 = (Dali::Rect< double > *)jarg1;
43885   arg2 = (Dali::Rect< double > *)jarg2;
43886   if (!arg2) {
43887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
43888     return 0;
43889   }
43890   {
43891     try {
43892       result = (bool)((Dali::Rect< double > const *)arg1)->Intersects((Dali::Rect< double > const &)*arg2);
43893     } catch (std::out_of_range& e) {
43894       {
43895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43896       };
43897     } catch (std::exception& e) {
43898       {
43899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43900       };
43901     } catch (...) {
43902       {
43903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43904       };
43905     }
43906   }
43907   jresult = result;
43908   return jresult;
43909 }
43910
43911
43912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectDouble_Contains(void * jarg1, void * jarg2) {
43913   unsigned int jresult ;
43914   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43915   Dali::Rect< double > *arg2 = 0 ;
43916   bool result;
43917
43918   arg1 = (Dali::Rect< double > *)jarg1;
43919   arg2 = (Dali::Rect< double > *)jarg2;
43920   if (!arg2) {
43921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
43922     return 0;
43923   }
43924   {
43925     try {
43926       result = (bool)((Dali::Rect< double > const *)arg1)->Contains((Dali::Rect< double > const &)*arg2);
43927     } catch (std::out_of_range& e) {
43928       {
43929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43930       };
43931     } catch (std::exception& e) {
43932       {
43933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43934       };
43935     } catch (...) {
43936       {
43937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43938       };
43939     }
43940   }
43941   jresult = result;
43942   return jresult;
43943 }
43944
43945
43946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_x_set(void * jarg1, double jarg2) {
43947   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43948   double arg2 ;
43949
43950   arg1 = (Dali::Rect< double > *)jarg1;
43951   arg2 = (double)jarg2;
43952   if (arg1) (arg1)->x = arg2;
43953 }
43954
43955
43956 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_x_get(void * jarg1) {
43957   double jresult ;
43958   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43959   double result;
43960
43961   arg1 = (Dali::Rect< double > *)jarg1;
43962   result = (double) ((arg1)->x);
43963   jresult = result;
43964   return jresult;
43965 }
43966
43967
43968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_left_set(void * jarg1, double jarg2) {
43969   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43970   double arg2 ;
43971
43972   arg1 = (Dali::Rect< double > *)jarg1;
43973   arg2 = (double)jarg2;
43974   if (arg1) (arg1)->left = arg2;
43975 }
43976
43977
43978 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_left_get(void * jarg1) {
43979   double jresult ;
43980   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43981   double result;
43982
43983   arg1 = (Dali::Rect< double > *)jarg1;
43984   result = (double) ((arg1)->left);
43985   jresult = result;
43986   return jresult;
43987 }
43988
43989
43990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_y_set(void * jarg1, double jarg2) {
43991   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
43992   double arg2 ;
43993
43994   arg1 = (Dali::Rect< double > *)jarg1;
43995   arg2 = (double)jarg2;
43996   if (arg1) (arg1)->y = arg2;
43997 }
43998
43999
44000 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_y_get(void * jarg1) {
44001   double jresult ;
44002   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44003   double result;
44004
44005   arg1 = (Dali::Rect< double > *)jarg1;
44006   result = (double) ((arg1)->y);
44007   jresult = result;
44008   return jresult;
44009 }
44010
44011
44012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_right_set(void * jarg1, double jarg2) {
44013   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44014   double arg2 ;
44015
44016   arg1 = (Dali::Rect< double > *)jarg1;
44017   arg2 = (double)jarg2;
44018   if (arg1) (arg1)->right = arg2;
44019 }
44020
44021
44022 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_right_get(void * jarg1) {
44023   double jresult ;
44024   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44025   double result;
44026
44027   arg1 = (Dali::Rect< double > *)jarg1;
44028   result = (double) ((arg1)->right);
44029   jresult = result;
44030   return jresult;
44031 }
44032
44033
44034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_width_set(void * jarg1, double jarg2) {
44035   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44036   double arg2 ;
44037
44038   arg1 = (Dali::Rect< double > *)jarg1;
44039   arg2 = (double)jarg2;
44040   if (arg1) (arg1)->width = arg2;
44041 }
44042
44043
44044 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_width_get(void * jarg1) {
44045   double jresult ;
44046   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44047   double result;
44048
44049   arg1 = (Dali::Rect< double > *)jarg1;
44050   result = (double) ((arg1)->width);
44051   jresult = result;
44052   return jresult;
44053 }
44054
44055
44056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_bottom_set(void * jarg1, double jarg2) {
44057   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44058   double arg2 ;
44059
44060   arg1 = (Dali::Rect< double > *)jarg1;
44061   arg2 = (double)jarg2;
44062   if (arg1) (arg1)->bottom = arg2;
44063 }
44064
44065
44066 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_bottom_get(void * jarg1) {
44067   double jresult ;
44068   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44069   double result;
44070
44071   arg1 = (Dali::Rect< double > *)jarg1;
44072   result = (double) ((arg1)->bottom);
44073   jresult = result;
44074   return jresult;
44075 }
44076
44077
44078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_height_set(void * jarg1, double jarg2) {
44079   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44080   double arg2 ;
44081
44082   arg1 = (Dali::Rect< double > *)jarg1;
44083   arg2 = (double)jarg2;
44084   if (arg1) (arg1)->height = arg2;
44085 }
44086
44087
44088 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_height_get(void * jarg1) {
44089   double jresult ;
44090   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44091   double result;
44092
44093   arg1 = (Dali::Rect< double > *)jarg1;
44094   result = (double) ((arg1)->height);
44095   jresult = result;
44096   return jresult;
44097 }
44098
44099
44100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_top_set(void * jarg1, double jarg2) {
44101   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44102   double arg2 ;
44103
44104   arg1 = (Dali::Rect< double > *)jarg1;
44105   arg2 = (double)jarg2;
44106   if (arg1) (arg1)->top = arg2;
44107 }
44108
44109
44110 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_top_get(void * jarg1) {
44111   double jresult ;
44112   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44113   double result;
44114
44115   arg1 = (Dali::Rect< double > *)jarg1;
44116   result = (double) ((arg1)->top);
44117   jresult = result;
44118   return jresult;
44119 }
44120
44121
44122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RectDouble(void * jarg1) {
44123   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
44124
44125   arg1 = (Dali::Rect< double > *)jarg1;
44126   {
44127     try {
44128       delete arg1;
44129     } catch (std::out_of_range& e) {
44130       {
44131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44132       };
44133     } catch (std::exception& e) {
44134       {
44135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44136       };
44137     } catch (...) {
44138       {
44139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44140       };
44141     }
44142   }
44143 }
44144
44145
44146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectInteger__SWIG_0() {
44147   void * jresult ;
44148   Dali::Rect< int > *result = 0 ;
44149
44150   {
44151     try {
44152       result = (Dali::Rect< int > *)new Dali::Rect< int >();
44153     } catch (std::out_of_range& e) {
44154       {
44155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44156       };
44157     } catch (std::exception& e) {
44158       {
44159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44160       };
44161     } catch (...) {
44162       {
44163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44164       };
44165     }
44166   }
44167   jresult = (void *)result;
44168   return jresult;
44169 }
44170
44171
44172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectInteger__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
44173   void * jresult ;
44174   int arg1 ;
44175   int arg2 ;
44176   int arg3 ;
44177   int arg4 ;
44178   Dali::Rect< int > *result = 0 ;
44179
44180   arg1 = (int)jarg1;
44181   arg2 = (int)jarg2;
44182   arg3 = (int)jarg3;
44183   arg4 = (int)jarg4;
44184   {
44185     try {
44186       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
44187     } catch (std::out_of_range& e) {
44188       {
44189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44190       };
44191     } catch (std::exception& e) {
44192       {
44193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44194       };
44195     } catch (...) {
44196       {
44197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44198       };
44199     }
44200   }
44201   jresult = (void *)result;
44202   return jresult;
44203 }
44204
44205
44206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectInteger__SWIG_2(void * jarg1) {
44207   void * jresult ;
44208   Dali::Rect< int > *arg1 = 0 ;
44209   Dali::Rect< int > *result = 0 ;
44210
44211   arg1 = (Dali::Rect< int > *)jarg1;
44212   if (!arg1) {
44213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
44214     return 0;
44215   }
44216   {
44217     try {
44218       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
44219     } catch (std::out_of_range& e) {
44220       {
44221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44222       };
44223     } catch (std::exception& e) {
44224       {
44225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44226       };
44227     } catch (...) {
44228       {
44229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44230       };
44231     }
44232   }
44233   jresult = (void *)result;
44234   return jresult;
44235 }
44236
44237
44238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RectInteger_Assign(void * jarg1, void * jarg2) {
44239   void * jresult ;
44240   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44241   Dali::Rect< int > *arg2 = 0 ;
44242   Dali::Rect< int > *result = 0 ;
44243
44244   arg1 = (Dali::Rect< int > *)jarg1;
44245   arg2 = (Dali::Rect< int > *)jarg2;
44246   if (!arg2) {
44247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
44248     return 0;
44249   }
44250   {
44251     try {
44252       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
44253     } catch (std::out_of_range& e) {
44254       {
44255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44256       };
44257     } catch (std::exception& e) {
44258       {
44259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44260       };
44261     } catch (...) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44264       };
44265     }
44266   }
44267   jresult = (void *)result;
44268   return jresult;
44269 }
44270
44271
44272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
44273   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44274   int arg2 ;
44275   int arg3 ;
44276   int arg4 ;
44277   int arg5 ;
44278
44279   arg1 = (Dali::Rect< int > *)jarg1;
44280   arg2 = (int)jarg2;
44281   arg3 = (int)jarg3;
44282   arg4 = (int)jarg4;
44283   arg5 = (int)jarg5;
44284   {
44285     try {
44286       (arg1)->Set(arg2,arg3,arg4,arg5);
44287     } catch (std::out_of_range& e) {
44288       {
44289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44290       };
44291     } catch (std::exception& e) {
44292       {
44293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44294       };
44295     } catch (...) {
44296       {
44297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44298       };
44299     }
44300   }
44301 }
44302
44303
44304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectInteger_IsEmpty(void * jarg1) {
44305   unsigned int jresult ;
44306   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44307   bool result;
44308
44309   arg1 = (Dali::Rect< int > *)jarg1;
44310   {
44311     try {
44312       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
44313     } catch (std::out_of_range& e) {
44314       {
44315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44316       };
44317     } catch (std::exception& e) {
44318       {
44319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44320       };
44321     } catch (...) {
44322       {
44323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44324       };
44325     }
44326   }
44327   jresult = result;
44328   return jresult;
44329 }
44330
44331
44332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Left(void * jarg1) {
44333   int jresult ;
44334   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44335   int result;
44336
44337   arg1 = (Dali::Rect< int > *)jarg1;
44338   {
44339     try {
44340       result = (int)((Dali::Rect< int > const *)arg1)->Left();
44341     } catch (std::out_of_range& e) {
44342       {
44343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44344       };
44345     } catch (std::exception& e) {
44346       {
44347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44348       };
44349     } catch (...) {
44350       {
44351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44352       };
44353     }
44354   }
44355   jresult = result;
44356   return jresult;
44357 }
44358
44359
44360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Right(void * jarg1) {
44361   int jresult ;
44362   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44363   int result;
44364
44365   arg1 = (Dali::Rect< int > *)jarg1;
44366   {
44367     try {
44368       result = (int)((Dali::Rect< int > const *)arg1)->Right();
44369     } catch (std::out_of_range& e) {
44370       {
44371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44372       };
44373     } catch (std::exception& e) {
44374       {
44375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44376       };
44377     } catch (...) {
44378       {
44379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44380       };
44381     }
44382   }
44383   jresult = result;
44384   return jresult;
44385 }
44386
44387
44388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Top(void * jarg1) {
44389   int jresult ;
44390   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44391   int result;
44392
44393   arg1 = (Dali::Rect< int > *)jarg1;
44394   {
44395     try {
44396       result = (int)((Dali::Rect< int > const *)arg1)->Top();
44397     } catch (std::out_of_range& e) {
44398       {
44399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44400       };
44401     } catch (std::exception& e) {
44402       {
44403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44404       };
44405     } catch (...) {
44406       {
44407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44408       };
44409     }
44410   }
44411   jresult = result;
44412   return jresult;
44413 }
44414
44415
44416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Bottom(void * jarg1) {
44417   int jresult ;
44418   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44419   int result;
44420
44421   arg1 = (Dali::Rect< int > *)jarg1;
44422   {
44423     try {
44424       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
44425     } catch (std::out_of_range& e) {
44426       {
44427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44428       };
44429     } catch (std::exception& e) {
44430       {
44431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44432       };
44433     } catch (...) {
44434       {
44435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44436       };
44437     }
44438   }
44439   jresult = result;
44440   return jresult;
44441 }
44442
44443
44444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Area(void * jarg1) {
44445   int jresult ;
44446   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44447   int result;
44448
44449   arg1 = (Dali::Rect< int > *)jarg1;
44450   {
44451     try {
44452       result = (int)((Dali::Rect< int > const *)arg1)->Area();
44453     } catch (std::out_of_range& e) {
44454       {
44455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44456       };
44457     } catch (std::exception& e) {
44458       {
44459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44460       };
44461     } catch (...) {
44462       {
44463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44464       };
44465     }
44466   }
44467   jresult = result;
44468   return jresult;
44469 }
44470
44471
44472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectInteger_Intersects(void * jarg1, void * jarg2) {
44473   unsigned int jresult ;
44474   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44475   Dali::Rect< int > *arg2 = 0 ;
44476   bool result;
44477
44478   arg1 = (Dali::Rect< int > *)jarg1;
44479   arg2 = (Dali::Rect< int > *)jarg2;
44480   if (!arg2) {
44481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
44482     return 0;
44483   }
44484   {
44485     try {
44486       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
44487     } catch (std::out_of_range& e) {
44488       {
44489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44490       };
44491     } catch (std::exception& e) {
44492       {
44493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44494       };
44495     } catch (...) {
44496       {
44497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44498       };
44499     }
44500   }
44501   jresult = result;
44502   return jresult;
44503 }
44504
44505
44506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectInteger_Contains(void * jarg1, void * jarg2) {
44507   unsigned int jresult ;
44508   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44509   Dali::Rect< int > *arg2 = 0 ;
44510   bool result;
44511
44512   arg1 = (Dali::Rect< int > *)jarg1;
44513   arg2 = (Dali::Rect< int > *)jarg2;
44514   if (!arg2) {
44515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
44516     return 0;
44517   }
44518   {
44519     try {
44520       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
44521     } catch (std::out_of_range& e) {
44522       {
44523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44524       };
44525     } catch (std::exception& e) {
44526       {
44527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44528       };
44529     } catch (...) {
44530       {
44531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44532       };
44533     }
44534   }
44535   jresult = result;
44536   return jresult;
44537 }
44538
44539
44540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_x_set(void * jarg1, int jarg2) {
44541   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44542   int arg2 ;
44543
44544   arg1 = (Dali::Rect< int > *)jarg1;
44545   arg2 = (int)jarg2;
44546   if (arg1) (arg1)->x = arg2;
44547 }
44548
44549
44550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_x_get(void * jarg1) {
44551   int jresult ;
44552   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44553   int result;
44554
44555   arg1 = (Dali::Rect< int > *)jarg1;
44556   result = (int) ((arg1)->x);
44557   jresult = result;
44558   return jresult;
44559 }
44560
44561
44562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_left_set(void * jarg1, int jarg2) {
44563   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44564   int arg2 ;
44565
44566   arg1 = (Dali::Rect< int > *)jarg1;
44567   arg2 = (int)jarg2;
44568   if (arg1) (arg1)->left = arg2;
44569 }
44570
44571
44572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_left_get(void * jarg1) {
44573   int jresult ;
44574   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44575   int result;
44576
44577   arg1 = (Dali::Rect< int > *)jarg1;
44578   result = (int) ((arg1)->left);
44579   jresult = result;
44580   return jresult;
44581 }
44582
44583
44584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_y_set(void * jarg1, int jarg2) {
44585   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44586   int arg2 ;
44587
44588   arg1 = (Dali::Rect< int > *)jarg1;
44589   arg2 = (int)jarg2;
44590   if (arg1) (arg1)->y = arg2;
44591 }
44592
44593
44594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_y_get(void * jarg1) {
44595   int jresult ;
44596   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44597   int result;
44598
44599   arg1 = (Dali::Rect< int > *)jarg1;
44600   result = (int) ((arg1)->y);
44601   jresult = result;
44602   return jresult;
44603 }
44604
44605
44606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_right_set(void * jarg1, int jarg2) {
44607   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44608   int arg2 ;
44609
44610   arg1 = (Dali::Rect< int > *)jarg1;
44611   arg2 = (int)jarg2;
44612   if (arg1) (arg1)->right = arg2;
44613 }
44614
44615
44616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_right_get(void * jarg1) {
44617   int jresult ;
44618   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44619   int result;
44620
44621   arg1 = (Dali::Rect< int > *)jarg1;
44622   result = (int) ((arg1)->right);
44623   jresult = result;
44624   return jresult;
44625 }
44626
44627
44628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_width_set(void * jarg1, int jarg2) {
44629   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44630   int arg2 ;
44631
44632   arg1 = (Dali::Rect< int > *)jarg1;
44633   arg2 = (int)jarg2;
44634   if (arg1) (arg1)->width = arg2;
44635 }
44636
44637
44638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_width_get(void * jarg1) {
44639   int jresult ;
44640   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44641   int result;
44642
44643   arg1 = (Dali::Rect< int > *)jarg1;
44644   result = (int) ((arg1)->width);
44645   jresult = result;
44646   return jresult;
44647 }
44648
44649
44650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_bottom_set(void * jarg1, int jarg2) {
44651   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44652   int arg2 ;
44653
44654   arg1 = (Dali::Rect< int > *)jarg1;
44655   arg2 = (int)jarg2;
44656   if (arg1) (arg1)->bottom = arg2;
44657 }
44658
44659
44660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_bottom_get(void * jarg1) {
44661   int jresult ;
44662   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44663   int result;
44664
44665   arg1 = (Dali::Rect< int > *)jarg1;
44666   result = (int) ((arg1)->bottom);
44667   jresult = result;
44668   return jresult;
44669 }
44670
44671
44672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_height_set(void * jarg1, int jarg2) {
44673   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44674   int arg2 ;
44675
44676   arg1 = (Dali::Rect< int > *)jarg1;
44677   arg2 = (int)jarg2;
44678   if (arg1) (arg1)->height = arg2;
44679 }
44680
44681
44682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_height_get(void * jarg1) {
44683   int jresult ;
44684   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44685   int result;
44686
44687   arg1 = (Dali::Rect< int > *)jarg1;
44688   result = (int) ((arg1)->height);
44689   jresult = result;
44690   return jresult;
44691 }
44692
44693
44694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_top_set(void * jarg1, int jarg2) {
44695   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44696   int arg2 ;
44697
44698   arg1 = (Dali::Rect< int > *)jarg1;
44699   arg2 = (int)jarg2;
44700   if (arg1) (arg1)->top = arg2;
44701 }
44702
44703
44704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_top_get(void * jarg1) {
44705   int jresult ;
44706   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44707   int result;
44708
44709   arg1 = (Dali::Rect< int > *)jarg1;
44710   result = (int) ((arg1)->top);
44711   jresult = result;
44712   return jresult;
44713 }
44714
44715
44716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RectInteger(void * jarg1) {
44717   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44718
44719   arg1 = (Dali::Rect< int > *)jarg1;
44720   {
44721     try {
44722       delete arg1;
44723     } catch (std::out_of_range& e) {
44724       {
44725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44726       };
44727     } catch (std::exception& e) {
44728       {
44729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44730       };
44731     } catch (...) {
44732       {
44733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44734       };
44735     }
44736   }
44737 }
44738
44739
44740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectUnsignedInteger__SWIG_0() {
44741   void * jresult ;
44742   Dali::Rect< unsigned int > *result = 0 ;
44743
44744   {
44745     try {
44746       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >();
44747     } catch (std::out_of_range& e) {
44748       {
44749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44750       };
44751     } catch (std::exception& e) {
44752       {
44753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44754       };
44755     } catch (...) {
44756       {
44757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44758       };
44759     }
44760   }
44761   jresult = (void *)result;
44762   return jresult;
44763 }
44764
44765
44766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectUnsignedInteger__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
44767   void * jresult ;
44768   unsigned int arg1 ;
44769   unsigned int arg2 ;
44770   unsigned int arg3 ;
44771   unsigned int arg4 ;
44772   Dali::Rect< unsigned int > *result = 0 ;
44773
44774   arg1 = (unsigned int)jarg1;
44775   arg2 = (unsigned int)jarg2;
44776   arg3 = (unsigned int)jarg3;
44777   arg4 = (unsigned int)jarg4;
44778   {
44779     try {
44780       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >(arg1,arg2,arg3,arg4);
44781     } catch (std::out_of_range& e) {
44782       {
44783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44784       };
44785     } catch (std::exception& e) {
44786       {
44787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44788       };
44789     } catch (...) {
44790       {
44791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44792       };
44793     }
44794   }
44795   jresult = (void *)result;
44796   return jresult;
44797 }
44798
44799
44800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectUnsignedInteger__SWIG_2(void * jarg1) {
44801   void * jresult ;
44802   Dali::Rect< unsigned int > *arg1 = 0 ;
44803   Dali::Rect< unsigned int > *result = 0 ;
44804
44805   arg1 = (Dali::Rect< unsigned int > *)jarg1;
44806   if (!arg1) {
44807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
44808     return 0;
44809   }
44810   {
44811     try {
44812       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >((Dali::Rect< unsigned int > const &)*arg1);
44813     } catch (std::out_of_range& e) {
44814       {
44815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44816       };
44817     } catch (std::exception& e) {
44818       {
44819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44820       };
44821     } catch (...) {
44822       {
44823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44824       };
44825     }
44826   }
44827   jresult = (void *)result;
44828   return jresult;
44829 }
44830
44831
44832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Assign(void * jarg1, void * jarg2) {
44833   void * jresult ;
44834   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
44835   Dali::Rect< unsigned int > *arg2 = 0 ;
44836   Dali::Rect< unsigned int > *result = 0 ;
44837
44838   arg1 = (Dali::Rect< unsigned int > *)jarg1;
44839   arg2 = (Dali::Rect< unsigned int > *)jarg2;
44840   if (!arg2) {
44841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
44842     return 0;
44843   }
44844   {
44845     try {
44846       result = (Dali::Rect< unsigned int > *) &(arg1)->operator =((Dali::Rect< unsigned int > const &)*arg2);
44847     } catch (std::out_of_range& e) {
44848       {
44849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44850       };
44851     } catch (std::exception& e) {
44852       {
44853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44854       };
44855     } catch (...) {
44856       {
44857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44858       };
44859     }
44860   }
44861   jresult = (void *)result;
44862   return jresult;
44863 }
44864
44865
44866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Set(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5) {
44867   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
44868   unsigned int arg2 ;
44869   unsigned int arg3 ;
44870   unsigned int arg4 ;
44871   unsigned int arg5 ;
44872
44873   arg1 = (Dali::Rect< unsigned int > *)jarg1;
44874   arg2 = (unsigned int)jarg2;
44875   arg3 = (unsigned int)jarg3;
44876   arg4 = (unsigned int)jarg4;
44877   arg5 = (unsigned int)jarg5;
44878   {
44879     try {
44880       (arg1)->Set(arg2,arg3,arg4,arg5);
44881     } catch (std::out_of_range& e) {
44882       {
44883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44884       };
44885     } catch (std::exception& e) {
44886       {
44887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44888       };
44889     } catch (...) {
44890       {
44891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44892       };
44893     }
44894   }
44895 }
44896
44897
44898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_IsEmpty(void * jarg1) {
44899   unsigned int jresult ;
44900   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
44901   bool result;
44902
44903   arg1 = (Dali::Rect< unsigned int > *)jarg1;
44904   {
44905     try {
44906       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->IsEmpty();
44907     } catch (std::out_of_range& e) {
44908       {
44909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44910       };
44911     } catch (std::exception& e) {
44912       {
44913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44914       };
44915     } catch (...) {
44916       {
44917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44918       };
44919     }
44920   }
44921   jresult = result;
44922   return jresult;
44923 }
44924
44925
44926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Left(void * jarg1) {
44927   unsigned int jresult ;
44928   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
44929   unsigned int result;
44930
44931   arg1 = (Dali::Rect< unsigned int > *)jarg1;
44932   {
44933     try {
44934       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Left();
44935     } catch (std::out_of_range& e) {
44936       {
44937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44938       };
44939     } catch (std::exception& e) {
44940       {
44941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44942       };
44943     } catch (...) {
44944       {
44945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44946       };
44947     }
44948   }
44949   jresult = result;
44950   return jresult;
44951 }
44952
44953
44954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Right(void * jarg1) {
44955   unsigned int jresult ;
44956   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
44957   unsigned int result;
44958
44959   arg1 = (Dali::Rect< unsigned int > *)jarg1;
44960   {
44961     try {
44962       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Right();
44963     } catch (std::out_of_range& e) {
44964       {
44965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44966       };
44967     } catch (std::exception& e) {
44968       {
44969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44970       };
44971     } catch (...) {
44972       {
44973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44974       };
44975     }
44976   }
44977   jresult = result;
44978   return jresult;
44979 }
44980
44981
44982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Top(void * jarg1) {
44983   unsigned int jresult ;
44984   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
44985   unsigned int result;
44986
44987   arg1 = (Dali::Rect< unsigned int > *)jarg1;
44988   {
44989     try {
44990       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Top();
44991     } catch (std::out_of_range& e) {
44992       {
44993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44994       };
44995     } catch (std::exception& e) {
44996       {
44997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44998       };
44999     } catch (...) {
45000       {
45001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45002       };
45003     }
45004   }
45005   jresult = result;
45006   return jresult;
45007 }
45008
45009
45010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Bottom(void * jarg1) {
45011   unsigned int jresult ;
45012   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45013   unsigned int result;
45014
45015   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45016   {
45017     try {
45018       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Bottom();
45019     } catch (std::out_of_range& e) {
45020       {
45021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45022       };
45023     } catch (std::exception& e) {
45024       {
45025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45026       };
45027     } catch (...) {
45028       {
45029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45030       };
45031     }
45032   }
45033   jresult = result;
45034   return jresult;
45035 }
45036
45037
45038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Area(void * jarg1) {
45039   unsigned int jresult ;
45040   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45041   unsigned int result;
45042
45043   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45044   {
45045     try {
45046       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Area();
45047     } catch (std::out_of_range& e) {
45048       {
45049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45050       };
45051     } catch (std::exception& e) {
45052       {
45053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45054       };
45055     } catch (...) {
45056       {
45057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45058       };
45059     }
45060   }
45061   jresult = result;
45062   return jresult;
45063 }
45064
45065
45066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Intersects(void * jarg1, void * jarg2) {
45067   unsigned int jresult ;
45068   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45069   Dali::Rect< unsigned int > *arg2 = 0 ;
45070   bool result;
45071
45072   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45073   arg2 = (Dali::Rect< unsigned int > *)jarg2;
45074   if (!arg2) {
45075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
45076     return 0;
45077   }
45078   {
45079     try {
45080       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->Intersects((Dali::Rect< unsigned int > const &)*arg2);
45081     } catch (std::out_of_range& e) {
45082       {
45083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45084       };
45085     } catch (std::exception& e) {
45086       {
45087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45088       };
45089     } catch (...) {
45090       {
45091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45092       };
45093     }
45094   }
45095   jresult = result;
45096   return jresult;
45097 }
45098
45099
45100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Contains(void * jarg1, void * jarg2) {
45101   unsigned int jresult ;
45102   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45103   Dali::Rect< unsigned int > *arg2 = 0 ;
45104   bool result;
45105
45106   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45107   arg2 = (Dali::Rect< unsigned int > *)jarg2;
45108   if (!arg2) {
45109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
45110     return 0;
45111   }
45112   {
45113     try {
45114       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->Contains((Dali::Rect< unsigned int > const &)*arg2);
45115     } catch (std::out_of_range& e) {
45116       {
45117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45118       };
45119     } catch (std::exception& e) {
45120       {
45121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45122       };
45123     } catch (...) {
45124       {
45125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45126       };
45127     }
45128   }
45129   jresult = result;
45130   return jresult;
45131 }
45132
45133
45134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_x_set(void * jarg1, unsigned int jarg2) {
45135   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45136   unsigned int arg2 ;
45137
45138   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45139   arg2 = (unsigned int)jarg2;
45140   if (arg1) (arg1)->x = arg2;
45141 }
45142
45143
45144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_x_get(void * jarg1) {
45145   unsigned int jresult ;
45146   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45147   unsigned int result;
45148
45149   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45150   result = (unsigned int) ((arg1)->x);
45151   jresult = result;
45152   return jresult;
45153 }
45154
45155
45156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_left_set(void * jarg1, unsigned int jarg2) {
45157   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45158   unsigned int arg2 ;
45159
45160   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45161   arg2 = (unsigned int)jarg2;
45162   if (arg1) (arg1)->left = arg2;
45163 }
45164
45165
45166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_left_get(void * jarg1) {
45167   unsigned int jresult ;
45168   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45169   unsigned int result;
45170
45171   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45172   result = (unsigned int) ((arg1)->left);
45173   jresult = result;
45174   return jresult;
45175 }
45176
45177
45178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_y_set(void * jarg1, unsigned int jarg2) {
45179   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45180   unsigned int arg2 ;
45181
45182   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45183   arg2 = (unsigned int)jarg2;
45184   if (arg1) (arg1)->y = arg2;
45185 }
45186
45187
45188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_y_get(void * jarg1) {
45189   unsigned int jresult ;
45190   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45191   unsigned int result;
45192
45193   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45194   result = (unsigned int) ((arg1)->y);
45195   jresult = result;
45196   return jresult;
45197 }
45198
45199
45200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_right_set(void * jarg1, unsigned int jarg2) {
45201   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45202   unsigned int arg2 ;
45203
45204   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45205   arg2 = (unsigned int)jarg2;
45206   if (arg1) (arg1)->right = arg2;
45207 }
45208
45209
45210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_right_get(void * jarg1) {
45211   unsigned int jresult ;
45212   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45213   unsigned int result;
45214
45215   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45216   result = (unsigned int) ((arg1)->right);
45217   jresult = result;
45218   return jresult;
45219 }
45220
45221
45222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_width_set(void * jarg1, unsigned int jarg2) {
45223   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45224   unsigned int arg2 ;
45225
45226   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45227   arg2 = (unsigned int)jarg2;
45228   if (arg1) (arg1)->width = arg2;
45229 }
45230
45231
45232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_width_get(void * jarg1) {
45233   unsigned int jresult ;
45234   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45235   unsigned int result;
45236
45237   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45238   result = (unsigned int) ((arg1)->width);
45239   jresult = result;
45240   return jresult;
45241 }
45242
45243
45244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_bottom_set(void * jarg1, unsigned int jarg2) {
45245   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45246   unsigned int arg2 ;
45247
45248   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45249   arg2 = (unsigned int)jarg2;
45250   if (arg1) (arg1)->bottom = arg2;
45251 }
45252
45253
45254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_bottom_get(void * jarg1) {
45255   unsigned int jresult ;
45256   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45257   unsigned int result;
45258
45259   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45260   result = (unsigned int) ((arg1)->bottom);
45261   jresult = result;
45262   return jresult;
45263 }
45264
45265
45266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_height_set(void * jarg1, unsigned int jarg2) {
45267   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45268   unsigned int arg2 ;
45269
45270   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45271   arg2 = (unsigned int)jarg2;
45272   if (arg1) (arg1)->height = arg2;
45273 }
45274
45275
45276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_height_get(void * jarg1) {
45277   unsigned int jresult ;
45278   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45279   unsigned int result;
45280
45281   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45282   result = (unsigned int) ((arg1)->height);
45283   jresult = result;
45284   return jresult;
45285 }
45286
45287
45288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_top_set(void * jarg1, unsigned int jarg2) {
45289   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45290   unsigned int arg2 ;
45291
45292   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45293   arg2 = (unsigned int)jarg2;
45294   if (arg1) (arg1)->top = arg2;
45295 }
45296
45297
45298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_top_get(void * jarg1) {
45299   unsigned int jresult ;
45300   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45301   unsigned int result;
45302
45303   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45304   result = (unsigned int) ((arg1)->top);
45305   jresult = result;
45306   return jresult;
45307 }
45308
45309
45310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RectUnsignedInteger(void * jarg1) {
45311   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
45312
45313   arg1 = (Dali::Rect< unsigned int > *)jarg1;
45314   {
45315     try {
45316       delete arg1;
45317     } catch (std::out_of_range& e) {
45318       {
45319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45320       };
45321     } catch (std::exception& e) {
45322       {
45323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45324       };
45325     } catch (...) {
45326       {
45327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45328       };
45329     }
45330   }
45331 }
45332
45333
45334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectFloat__SWIG_0() {
45335   void * jresult ;
45336   Dali::Rect< float > *result = 0 ;
45337
45338   {
45339     try {
45340       result = (Dali::Rect< float > *)new Dali::Rect< float >();
45341     } catch (std::out_of_range& e) {
45342       {
45343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45344       };
45345     } catch (std::exception& e) {
45346       {
45347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45348       };
45349     } catch (...) {
45350       {
45351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45352       };
45353     }
45354   }
45355   jresult = (void *)result;
45356   return jresult;
45357 }
45358
45359
45360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectFloat__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
45361   void * jresult ;
45362   float arg1 ;
45363   float arg2 ;
45364   float arg3 ;
45365   float arg4 ;
45366   Dali::Rect< float > *result = 0 ;
45367
45368   arg1 = (float)jarg1;
45369   arg2 = (float)jarg2;
45370   arg3 = (float)jarg3;
45371   arg4 = (float)jarg4;
45372   {
45373     try {
45374       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
45375     } catch (std::out_of_range& e) {
45376       {
45377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45378       };
45379     } catch (std::exception& e) {
45380       {
45381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45382       };
45383     } catch (...) {
45384       {
45385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45386       };
45387     }
45388   }
45389   jresult = (void *)result;
45390   return jresult;
45391 }
45392
45393
45394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectFloat__SWIG_2(void * jarg1) {
45395   void * jresult ;
45396   Dali::Rect< float > *arg1 = 0 ;
45397   Dali::Rect< float > *result = 0 ;
45398
45399   arg1 = (Dali::Rect< float > *)jarg1;
45400   if (!arg1) {
45401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
45402     return 0;
45403   }
45404   {
45405     try {
45406       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
45407     } catch (std::out_of_range& e) {
45408       {
45409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45410       };
45411     } catch (std::exception& e) {
45412       {
45413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45414       };
45415     } catch (...) {
45416       {
45417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45418       };
45419     }
45420   }
45421   jresult = (void *)result;
45422   return jresult;
45423 }
45424
45425
45426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RectFloat_Assign(void * jarg1, void * jarg2) {
45427   void * jresult ;
45428   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45429   Dali::Rect< float > *arg2 = 0 ;
45430   Dali::Rect< float > *result = 0 ;
45431
45432   arg1 = (Dali::Rect< float > *)jarg1;
45433   arg2 = (Dali::Rect< float > *)jarg2;
45434   if (!arg2) {
45435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
45436     return 0;
45437   }
45438   {
45439     try {
45440       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
45441     } catch (std::out_of_range& e) {
45442       {
45443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45444       };
45445     } catch (std::exception& e) {
45446       {
45447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45448       };
45449     } catch (...) {
45450       {
45451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45452       };
45453     }
45454   }
45455   jresult = (void *)result;
45456   return jresult;
45457 }
45458
45459
45460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
45461   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45462   float arg2 ;
45463   float arg3 ;
45464   float arg4 ;
45465   float arg5 ;
45466
45467   arg1 = (Dali::Rect< float > *)jarg1;
45468   arg2 = (float)jarg2;
45469   arg3 = (float)jarg3;
45470   arg4 = (float)jarg4;
45471   arg5 = (float)jarg5;
45472   {
45473     try {
45474       (arg1)->Set(arg2,arg3,arg4,arg5);
45475     } catch (std::out_of_range& e) {
45476       {
45477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45478       };
45479     } catch (std::exception& e) {
45480       {
45481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45482       };
45483     } catch (...) {
45484       {
45485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45486       };
45487     }
45488   }
45489 }
45490
45491
45492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectFloat_IsEmpty(void * jarg1) {
45493   unsigned int jresult ;
45494   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45495   bool result;
45496
45497   arg1 = (Dali::Rect< float > *)jarg1;
45498   {
45499     try {
45500       result = (bool)((Dali::Rect< float > const *)arg1)->IsEmpty();
45501     } catch (std::out_of_range& e) {
45502       {
45503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45504       };
45505     } catch (std::exception& e) {
45506       {
45507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45508       };
45509     } catch (...) {
45510       {
45511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45512       };
45513     }
45514   }
45515   jresult = result;
45516   return jresult;
45517 }
45518
45519
45520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Left(void * jarg1) {
45521   float jresult ;
45522   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45523   float result;
45524
45525   arg1 = (Dali::Rect< float > *)jarg1;
45526   {
45527     try {
45528       result = (float)((Dali::Rect< float > const *)arg1)->Left();
45529     } catch (std::out_of_range& e) {
45530       {
45531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45532       };
45533     } catch (std::exception& e) {
45534       {
45535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45536       };
45537     } catch (...) {
45538       {
45539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45540       };
45541     }
45542   }
45543   jresult = result;
45544   return jresult;
45545 }
45546
45547
45548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Right(void * jarg1) {
45549   float jresult ;
45550   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45551   float result;
45552
45553   arg1 = (Dali::Rect< float > *)jarg1;
45554   {
45555     try {
45556       result = (float)((Dali::Rect< float > const *)arg1)->Right();
45557     } catch (std::out_of_range& e) {
45558       {
45559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45560       };
45561     } catch (std::exception& e) {
45562       {
45563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45564       };
45565     } catch (...) {
45566       {
45567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45568       };
45569     }
45570   }
45571   jresult = result;
45572   return jresult;
45573 }
45574
45575
45576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Top(void * jarg1) {
45577   float jresult ;
45578   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45579   float result;
45580
45581   arg1 = (Dali::Rect< float > *)jarg1;
45582   {
45583     try {
45584       result = (float)((Dali::Rect< float > const *)arg1)->Top();
45585     } catch (std::out_of_range& e) {
45586       {
45587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45588       };
45589     } catch (std::exception& e) {
45590       {
45591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45592       };
45593     } catch (...) {
45594       {
45595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45596       };
45597     }
45598   }
45599   jresult = result;
45600   return jresult;
45601 }
45602
45603
45604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Bottom(void * jarg1) {
45605   float jresult ;
45606   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45607   float result;
45608
45609   arg1 = (Dali::Rect< float > *)jarg1;
45610   {
45611     try {
45612       result = (float)((Dali::Rect< float > const *)arg1)->Bottom();
45613     } catch (std::out_of_range& e) {
45614       {
45615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45616       };
45617     } catch (std::exception& e) {
45618       {
45619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45620       };
45621     } catch (...) {
45622       {
45623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45624       };
45625     }
45626   }
45627   jresult = result;
45628   return jresult;
45629 }
45630
45631
45632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Area(void * jarg1) {
45633   float jresult ;
45634   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45635   float result;
45636
45637   arg1 = (Dali::Rect< float > *)jarg1;
45638   {
45639     try {
45640       result = (float)((Dali::Rect< float > const *)arg1)->Area();
45641     } catch (std::out_of_range& e) {
45642       {
45643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45644       };
45645     } catch (std::exception& e) {
45646       {
45647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45648       };
45649     } catch (...) {
45650       {
45651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45652       };
45653     }
45654   }
45655   jresult = result;
45656   return jresult;
45657 }
45658
45659
45660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectFloat_Intersects(void * jarg1, void * jarg2) {
45661   unsigned int jresult ;
45662   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45663   Dali::Rect< float > *arg2 = 0 ;
45664   bool result;
45665
45666   arg1 = (Dali::Rect< float > *)jarg1;
45667   arg2 = (Dali::Rect< float > *)jarg2;
45668   if (!arg2) {
45669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
45670     return 0;
45671   }
45672   {
45673     try {
45674       result = (bool)((Dali::Rect< float > const *)arg1)->Intersects((Dali::Rect< float > const &)*arg2);
45675     } catch (std::out_of_range& e) {
45676       {
45677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45678       };
45679     } catch (std::exception& e) {
45680       {
45681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45682       };
45683     } catch (...) {
45684       {
45685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45686       };
45687     }
45688   }
45689   jresult = result;
45690   return jresult;
45691 }
45692
45693
45694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectFloat_Contains(void * jarg1, void * jarg2) {
45695   unsigned int jresult ;
45696   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45697   Dali::Rect< float > *arg2 = 0 ;
45698   bool result;
45699
45700   arg1 = (Dali::Rect< float > *)jarg1;
45701   arg2 = (Dali::Rect< float > *)jarg2;
45702   if (!arg2) {
45703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
45704     return 0;
45705   }
45706   {
45707     try {
45708       result = (bool)((Dali::Rect< float > const *)arg1)->Contains((Dali::Rect< float > const &)*arg2);
45709     } catch (std::out_of_range& e) {
45710       {
45711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45712       };
45713     } catch (std::exception& e) {
45714       {
45715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45716       };
45717     } catch (...) {
45718       {
45719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45720       };
45721     }
45722   }
45723   jresult = result;
45724   return jresult;
45725 }
45726
45727
45728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_x_set(void * jarg1, float jarg2) {
45729   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45730   float arg2 ;
45731
45732   arg1 = (Dali::Rect< float > *)jarg1;
45733   arg2 = (float)jarg2;
45734   if (arg1) (arg1)->x = arg2;
45735 }
45736
45737
45738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_x_get(void * jarg1) {
45739   float jresult ;
45740   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45741   float result;
45742
45743   arg1 = (Dali::Rect< float > *)jarg1;
45744   result = (float) ((arg1)->x);
45745   jresult = result;
45746   return jresult;
45747 }
45748
45749
45750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_left_set(void * jarg1, float jarg2) {
45751   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45752   float arg2 ;
45753
45754   arg1 = (Dali::Rect< float > *)jarg1;
45755   arg2 = (float)jarg2;
45756   if (arg1) (arg1)->left = arg2;
45757 }
45758
45759
45760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_left_get(void * jarg1) {
45761   float jresult ;
45762   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45763   float result;
45764
45765   arg1 = (Dali::Rect< float > *)jarg1;
45766   result = (float) ((arg1)->left);
45767   jresult = result;
45768   return jresult;
45769 }
45770
45771
45772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_y_set(void * jarg1, float jarg2) {
45773   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45774   float arg2 ;
45775
45776   arg1 = (Dali::Rect< float > *)jarg1;
45777   arg2 = (float)jarg2;
45778   if (arg1) (arg1)->y = arg2;
45779 }
45780
45781
45782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_y_get(void * jarg1) {
45783   float jresult ;
45784   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45785   float result;
45786
45787   arg1 = (Dali::Rect< float > *)jarg1;
45788   result = (float) ((arg1)->y);
45789   jresult = result;
45790   return jresult;
45791 }
45792
45793
45794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_right_set(void * jarg1, float jarg2) {
45795   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45796   float arg2 ;
45797
45798   arg1 = (Dali::Rect< float > *)jarg1;
45799   arg2 = (float)jarg2;
45800   if (arg1) (arg1)->right = arg2;
45801 }
45802
45803
45804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_right_get(void * jarg1) {
45805   float jresult ;
45806   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45807   float result;
45808
45809   arg1 = (Dali::Rect< float > *)jarg1;
45810   result = (float) ((arg1)->right);
45811   jresult = result;
45812   return jresult;
45813 }
45814
45815
45816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_width_set(void * jarg1, float jarg2) {
45817   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45818   float arg2 ;
45819
45820   arg1 = (Dali::Rect< float > *)jarg1;
45821   arg2 = (float)jarg2;
45822   if (arg1) (arg1)->width = arg2;
45823 }
45824
45825
45826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_width_get(void * jarg1) {
45827   float jresult ;
45828   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45829   float result;
45830
45831   arg1 = (Dali::Rect< float > *)jarg1;
45832   result = (float) ((arg1)->width);
45833   jresult = result;
45834   return jresult;
45835 }
45836
45837
45838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_bottom_set(void * jarg1, float jarg2) {
45839   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45840   float arg2 ;
45841
45842   arg1 = (Dali::Rect< float > *)jarg1;
45843   arg2 = (float)jarg2;
45844   if (arg1) (arg1)->bottom = arg2;
45845 }
45846
45847
45848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_bottom_get(void * jarg1) {
45849   float jresult ;
45850   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45851   float result;
45852
45853   arg1 = (Dali::Rect< float > *)jarg1;
45854   result = (float) ((arg1)->bottom);
45855   jresult = result;
45856   return jresult;
45857 }
45858
45859
45860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_height_set(void * jarg1, float jarg2) {
45861   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45862   float arg2 ;
45863
45864   arg1 = (Dali::Rect< float > *)jarg1;
45865   arg2 = (float)jarg2;
45866   if (arg1) (arg1)->height = arg2;
45867 }
45868
45869
45870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_height_get(void * jarg1) {
45871   float jresult ;
45872   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45873   float result;
45874
45875   arg1 = (Dali::Rect< float > *)jarg1;
45876   result = (float) ((arg1)->height);
45877   jresult = result;
45878   return jresult;
45879 }
45880
45881
45882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_top_set(void * jarg1, float jarg2) {
45883   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45884   float arg2 ;
45885
45886   arg1 = (Dali::Rect< float > *)jarg1;
45887   arg2 = (float)jarg2;
45888   if (arg1) (arg1)->top = arg2;
45889 }
45890
45891
45892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_top_get(void * jarg1) {
45893   float jresult ;
45894   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45895   float result;
45896
45897   arg1 = (Dali::Rect< float > *)jarg1;
45898   result = (float) ((arg1)->top);
45899   jresult = result;
45900   return jresult;
45901 }
45902
45903
45904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RectFloat(void * jarg1) {
45905   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45906
45907   arg1 = (Dali::Rect< float > *)jarg1;
45908   {
45909     try {
45910       delete arg1;
45911     } catch (std::out_of_range& e) {
45912       {
45913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45914       };
45915     } catch (std::exception& e) {
45916       {
45917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45918       };
45919     } catch (...) {
45920       {
45921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45922       };
45923     }
45924   }
45925 }
45926
45927
45928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
45929   int jresult ;
45930   int result;
45931
45932   result = (int)Dali::Vector< int >::BaseType;
45933   jresult = (int)result;
45934   return jresult;
45935 }
45936
45937
45938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
45939   void * jresult ;
45940   Dali::Vector< int > *result = 0 ;
45941
45942   {
45943     try {
45944       result = (Dali::Vector< int > *)new Dali::Vector< int >();
45945     } catch (std::out_of_range& e) {
45946       {
45947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45948       };
45949     } catch (std::exception& e) {
45950       {
45951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45952       };
45953     } catch (...) {
45954       {
45955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45956       };
45957     }
45958   }
45959   jresult = (void *)result;
45960   return jresult;
45961 }
45962
45963
45964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
45965   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
45966
45967   arg1 = (Dali::Vector< int > *)jarg1;
45968   {
45969     try {
45970       delete arg1;
45971     } catch (std::out_of_range& e) {
45972       {
45973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45974       };
45975     } catch (std::exception& e) {
45976       {
45977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45978       };
45979     } catch (...) {
45980       {
45981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45982       };
45983     }
45984   }
45985 }
45986
45987
45988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
45989   void * jresult ;
45990   Dali::Vector< int > *arg1 = 0 ;
45991   Dali::Vector< int > *result = 0 ;
45992
45993   arg1 = (Dali::Vector< int > *)jarg1;
45994   if (!arg1) {
45995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
45996     return 0;
45997   }
45998   {
45999     try {
46000       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46001     } catch (std::out_of_range& e) {
46002       {
46003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46004       };
46005     } catch (std::exception& e) {
46006       {
46007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46008       };
46009     } catch (...) {
46010       {
46011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46012       };
46013     }
46014   }
46015   jresult = (void *)result;
46016   return jresult;
46017 }
46018
46019
46020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46021   void * jresult ;
46022   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46023   Dali::Vector< int > *arg2 = 0 ;
46024   Dali::Vector< int > *result = 0 ;
46025
46026   arg1 = (Dali::Vector< int > *)jarg1;
46027   arg2 = (Dali::Vector< int > *)jarg2;
46028   if (!arg2) {
46029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46030     return 0;
46031   }
46032   {
46033     try {
46034       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46035     } catch (std::out_of_range& e) {
46036       {
46037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46038       };
46039     } catch (std::exception& e) {
46040       {
46041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46042       };
46043     } catch (...) {
46044       {
46045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46046       };
46047     }
46048   }
46049   jresult = (void *)result;
46050   return jresult;
46051 }
46052
46053
46054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46055   void * jresult ;
46056   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46057   Dali::Vector< int >::Iterator result;
46058
46059   arg1 = (Dali::Vector< int > *)jarg1;
46060   {
46061     try {
46062       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46063     } catch (std::out_of_range& e) {
46064       {
46065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46066       };
46067     } catch (std::exception& e) {
46068       {
46069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46070       };
46071     } catch (...) {
46072       {
46073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46074       };
46075     }
46076   }
46077   jresult = (void *)result;
46078   return jresult;
46079 }
46080
46081
46082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46083   void * jresult ;
46084   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46085   Dali::Vector< int >::Iterator result;
46086
46087   arg1 = (Dali::Vector< int > *)jarg1;
46088   {
46089     try {
46090       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46091     } catch (std::out_of_range& e) {
46092       {
46093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46094       };
46095     } catch (std::exception& e) {
46096       {
46097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46098       };
46099     } catch (...) {
46100       {
46101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46102       };
46103     }
46104   }
46105   jresult = (void *)result;
46106   return jresult;
46107 }
46108
46109
46110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46111   void * jresult ;
46112   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46113   Dali::Vector< int >::SizeType arg2 ;
46114   Dali::Vector< int >::ItemType *result = 0 ;
46115
46116   arg1 = (Dali::Vector< int > *)jarg1;
46117   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46118   {
46119     try {
46120       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46121     } catch (std::out_of_range& e) {
46122       {
46123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46124       };
46125     } catch (std::exception& e) {
46126       {
46127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46128       };
46129     } catch (...) {
46130       {
46131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46132       };
46133     }
46134   }
46135   jresult = (void *)result;
46136   return jresult;
46137 }
46138
46139
46140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46141   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46142   Dali::Vector< int >::ItemType *arg2 = 0 ;
46143   Dali::Vector< int >::ItemType temp2 ;
46144
46145   arg1 = (Dali::Vector< int > *)jarg1;
46146   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46147   arg2 = &temp2;
46148   {
46149     try {
46150       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46151     } catch (std::out_of_range& e) {
46152       {
46153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46154       };
46155     } catch (std::exception& e) {
46156       {
46157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46158       };
46159     } catch (...) {
46160       {
46161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46162       };
46163     }
46164   }
46165 }
46166
46167
46168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46169   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46170   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46171   Dali::Vector< int >::ItemType *arg3 = 0 ;
46172   Dali::Vector< int >::ItemType temp3 ;
46173
46174   arg1 = (Dali::Vector< int > *)jarg1;
46175   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46176   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46177   arg3 = &temp3;
46178   {
46179     try {
46180       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46181     } catch (std::out_of_range& e) {
46182       {
46183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46184       };
46185     } catch (std::exception& e) {
46186       {
46187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46188       };
46189     } catch (...) {
46190       {
46191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46192       };
46193     }
46194   }
46195 }
46196
46197
46198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46199   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46200   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46201   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46202   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46203
46204   arg1 = (Dali::Vector< int > *)jarg1;
46205   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46206   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46207   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46208   {
46209     try {
46210       (arg1)->Insert(arg2,arg3,arg4);
46211     } catch (std::out_of_range& e) {
46212       {
46213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46214       };
46215     } catch (std::exception& e) {
46216       {
46217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46218       };
46219     } catch (...) {
46220       {
46221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46222       };
46223     }
46224   }
46225 }
46226
46227
46228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46229   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46230   Dali::Vector< int >::SizeType arg2 ;
46231
46232   arg1 = (Dali::Vector< int > *)jarg1;
46233   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46234   {
46235     try {
46236       (arg1)->Reserve(arg2);
46237     } catch (std::out_of_range& e) {
46238       {
46239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46240       };
46241     } catch (std::exception& e) {
46242       {
46243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46244       };
46245     } catch (...) {
46246       {
46247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46248       };
46249     }
46250   }
46251 }
46252
46253
46254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46255   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46256   Dali::Vector< int >::SizeType arg2 ;
46257
46258   arg1 = (Dali::Vector< int > *)jarg1;
46259   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46260   {
46261     try {
46262       (arg1)->Resize(arg2);
46263     } catch (std::out_of_range& e) {
46264       {
46265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46266       };
46267     } catch (std::exception& e) {
46268       {
46269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46270       };
46271     } catch (...) {
46272       {
46273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46274       };
46275     }
46276   }
46277 }
46278
46279
46280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46281   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46282   Dali::Vector< int >::SizeType arg2 ;
46283   Dali::Vector< int >::ItemType *arg3 = 0 ;
46284   Dali::Vector< int >::ItemType temp3 ;
46285
46286   arg1 = (Dali::Vector< int > *)jarg1;
46287   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46288   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46289   arg3 = &temp3;
46290   {
46291     try {
46292       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46293     } catch (std::out_of_range& e) {
46294       {
46295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46296       };
46297     } catch (std::exception& e) {
46298       {
46299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46300       };
46301     } catch (...) {
46302       {
46303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46304       };
46305     }
46306   }
46307 }
46308
46309
46310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46311   void * jresult ;
46312   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46313   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46314   Dali::Vector< int >::Iterator result;
46315
46316   arg1 = (Dali::Vector< int > *)jarg1;
46317   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46318   {
46319     try {
46320       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46321     } catch (std::out_of_range& e) {
46322       {
46323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46324       };
46325     } catch (std::exception& e) {
46326       {
46327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46328       };
46329     } catch (...) {
46330       {
46331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46332       };
46333     }
46334   }
46335   jresult = (void *)result;
46336   return jresult;
46337 }
46338
46339
46340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46341   void * jresult ;
46342   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46343   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46344   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46345   Dali::Vector< int >::Iterator result;
46346
46347   arg1 = (Dali::Vector< int > *)jarg1;
46348   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46349   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46350   {
46351     try {
46352       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46353     } catch (std::out_of_range& e) {
46354       {
46355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46356       };
46357     } catch (std::exception& e) {
46358       {
46359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46360       };
46361     } catch (...) {
46362       {
46363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46364       };
46365     }
46366   }
46367   jresult = (void *)result;
46368   return jresult;
46369 }
46370
46371
46372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46373   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46374   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46375
46376   arg1 = (Dali::Vector< int > *)jarg1;
46377   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46378   {
46379     try {
46380       (arg1)->Remove(arg2);
46381     } catch (std::out_of_range& e) {
46382       {
46383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46384       };
46385     } catch (std::exception& e) {
46386       {
46387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46388       };
46389     } catch (...) {
46390       {
46391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46392       };
46393     }
46394   }
46395 }
46396
46397
46398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46399   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46400   Dali::Vector< int > *arg2 = 0 ;
46401
46402   arg1 = (Dali::Vector< int > *)jarg1;
46403   arg2 = (Dali::Vector< int > *)jarg2;
46404   if (!arg2) {
46405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
46406     return ;
46407   }
46408   {
46409     try {
46410       (arg1)->Swap(*arg2);
46411     } catch (std::out_of_range& e) {
46412       {
46413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46414       };
46415     } catch (std::exception& e) {
46416       {
46417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46418       };
46419     } catch (...) {
46420       {
46421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46422       };
46423     }
46424   }
46425 }
46426
46427
46428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
46429   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46430
46431   arg1 = (Dali::Vector< int > *)jarg1;
46432   {
46433     try {
46434       (arg1)->Clear();
46435     } catch (std::out_of_range& e) {
46436       {
46437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46438       };
46439     } catch (std::exception& e) {
46440       {
46441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46442       };
46443     } catch (...) {
46444       {
46445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46446       };
46447     }
46448   }
46449 }
46450
46451
46452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
46453   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46454
46455   arg1 = (Dali::Vector< int > *)jarg1;
46456   {
46457     try {
46458       (arg1)->Release();
46459     } catch (std::out_of_range& e) {
46460       {
46461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46462       };
46463     } catch (std::exception& e) {
46464       {
46465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46466       };
46467     } catch (...) {
46468       {
46469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46470       };
46471     }
46472   }
46473 }
46474
46475
46476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
46477   int jresult ;
46478   int result;
46479
46480   result = (int)Dali::Vector< float >::BaseType;
46481   jresult = (int)result;
46482   return jresult;
46483 }
46484
46485
46486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
46487   void * jresult ;
46488   Dali::Vector< float > *result = 0 ;
46489
46490   {
46491     try {
46492       result = (Dali::Vector< float > *)new Dali::Vector< float >();
46493     } catch (std::out_of_range& e) {
46494       {
46495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46496       };
46497     } catch (std::exception& e) {
46498       {
46499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46500       };
46501     } catch (...) {
46502       {
46503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46504       };
46505     }
46506   }
46507   jresult = (void *)result;
46508   return jresult;
46509 }
46510
46511
46512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
46513   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46514
46515   arg1 = (Dali::Vector< float > *)jarg1;
46516   {
46517     try {
46518       delete arg1;
46519     } catch (std::out_of_range& e) {
46520       {
46521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46522       };
46523     } catch (std::exception& e) {
46524       {
46525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46526       };
46527     } catch (...) {
46528       {
46529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46530       };
46531     }
46532   }
46533 }
46534
46535
46536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
46537   void * jresult ;
46538   Dali::Vector< float > *arg1 = 0 ;
46539   Dali::Vector< float > *result = 0 ;
46540
46541   arg1 = (Dali::Vector< float > *)jarg1;
46542   if (!arg1) {
46543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46544     return 0;
46545   }
46546   {
46547     try {
46548       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
46549     } catch (std::out_of_range& e) {
46550       {
46551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46552       };
46553     } catch (std::exception& e) {
46554       {
46555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46556       };
46557     } catch (...) {
46558       {
46559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46560       };
46561     }
46562   }
46563   jresult = (void *)result;
46564   return jresult;
46565 }
46566
46567
46568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
46569   void * jresult ;
46570   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46571   Dali::Vector< float > *arg2 = 0 ;
46572   Dali::Vector< float > *result = 0 ;
46573
46574   arg1 = (Dali::Vector< float > *)jarg1;
46575   arg2 = (Dali::Vector< float > *)jarg2;
46576   if (!arg2) {
46577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46578     return 0;
46579   }
46580   {
46581     try {
46582       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
46583     } catch (std::out_of_range& e) {
46584       {
46585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46586       };
46587     } catch (std::exception& e) {
46588       {
46589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46590       };
46591     } catch (...) {
46592       {
46593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46594       };
46595     }
46596   }
46597   jresult = (void *)result;
46598   return jresult;
46599 }
46600
46601
46602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
46603   void * jresult ;
46604   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46605   Dali::Vector< float >::Iterator result;
46606
46607   arg1 = (Dali::Vector< float > *)jarg1;
46608   {
46609     try {
46610       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
46611     } catch (std::out_of_range& e) {
46612       {
46613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46614       };
46615     } catch (std::exception& e) {
46616       {
46617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46618       };
46619     } catch (...) {
46620       {
46621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46622       };
46623     }
46624   }
46625   jresult = (void *)result;
46626   return jresult;
46627 }
46628
46629
46630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
46631   void * jresult ;
46632   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46633   Dali::Vector< float >::Iterator result;
46634
46635   arg1 = (Dali::Vector< float > *)jarg1;
46636   {
46637     try {
46638       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
46639     } catch (std::out_of_range& e) {
46640       {
46641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46642       };
46643     } catch (std::exception& e) {
46644       {
46645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46646       };
46647     } catch (...) {
46648       {
46649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46650       };
46651     }
46652   }
46653   jresult = (void *)result;
46654   return jresult;
46655 }
46656
46657
46658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46659   void * jresult ;
46660   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46661   Dali::Vector< float >::SizeType arg2 ;
46662   Dali::Vector< float >::ItemType *result = 0 ;
46663
46664   arg1 = (Dali::Vector< float > *)jarg1;
46665   arg2 = (Dali::Vector< float >::SizeType)jarg2;
46666   {
46667     try {
46668       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
46669     } catch (std::out_of_range& e) {
46670       {
46671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46672       };
46673     } catch (std::exception& e) {
46674       {
46675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46676       };
46677     } catch (...) {
46678       {
46679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46680       };
46681     }
46682   }
46683   jresult = (void *)result;
46684   return jresult;
46685 }
46686
46687
46688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
46689   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46690   Dali::Vector< float >::ItemType *arg2 = 0 ;
46691   Dali::Vector< float >::ItemType temp2 ;
46692
46693   arg1 = (Dali::Vector< float > *)jarg1;
46694   temp2 = (Dali::Vector< float >::ItemType)jarg2;
46695   arg2 = &temp2;
46696   {
46697     try {
46698       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
46699     } catch (std::out_of_range& e) {
46700       {
46701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46702       };
46703     } catch (std::exception& e) {
46704       {
46705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46706       };
46707     } catch (...) {
46708       {
46709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46710       };
46711     }
46712   }
46713 }
46714
46715
46716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
46717   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46718   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
46719   Dali::Vector< float >::ItemType *arg3 = 0 ;
46720   Dali::Vector< float >::ItemType temp3 ;
46721
46722   arg1 = (Dali::Vector< float > *)jarg1;
46723   arg2 = (Dali::Vector< float >::Iterator)jarg2;
46724   temp3 = (Dali::Vector< float >::ItemType)jarg3;
46725   arg3 = &temp3;
46726   {
46727     try {
46728       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
46729     } catch (std::out_of_range& e) {
46730       {
46731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46732       };
46733     } catch (std::exception& e) {
46734       {
46735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46736       };
46737     } catch (...) {
46738       {
46739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46740       };
46741     }
46742   }
46743 }
46744
46745
46746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46747   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46748   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
46749   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
46750   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
46751
46752   arg1 = (Dali::Vector< float > *)jarg1;
46753   arg2 = (Dali::Vector< float >::Iterator)jarg2;
46754   arg3 = (Dali::Vector< float >::Iterator)jarg3;
46755   arg4 = (Dali::Vector< float >::Iterator)jarg4;
46756   {
46757     try {
46758       (arg1)->Insert(arg2,arg3,arg4);
46759     } catch (std::out_of_range& e) {
46760       {
46761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46762       };
46763     } catch (std::exception& e) {
46764       {
46765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46766       };
46767     } catch (...) {
46768       {
46769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46770       };
46771     }
46772   }
46773 }
46774
46775
46776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
46777   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46778   Dali::Vector< float >::SizeType arg2 ;
46779
46780   arg1 = (Dali::Vector< float > *)jarg1;
46781   arg2 = (Dali::Vector< float >::SizeType)jarg2;
46782   {
46783     try {
46784       (arg1)->Reserve(arg2);
46785     } catch (std::out_of_range& e) {
46786       {
46787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46788       };
46789     } catch (std::exception& e) {
46790       {
46791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46792       };
46793     } catch (...) {
46794       {
46795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46796       };
46797     }
46798   }
46799 }
46800
46801
46802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46803   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46804   Dali::Vector< float >::SizeType arg2 ;
46805
46806   arg1 = (Dali::Vector< float > *)jarg1;
46807   arg2 = (Dali::Vector< float >::SizeType)jarg2;
46808   {
46809     try {
46810       (arg1)->Resize(arg2);
46811     } catch (std::out_of_range& e) {
46812       {
46813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46814       };
46815     } catch (std::exception& e) {
46816       {
46817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46818       };
46819     } catch (...) {
46820       {
46821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46822       };
46823     }
46824   }
46825 }
46826
46827
46828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
46829   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46830   Dali::Vector< float >::SizeType arg2 ;
46831   Dali::Vector< float >::ItemType *arg3 = 0 ;
46832   Dali::Vector< float >::ItemType temp3 ;
46833
46834   arg1 = (Dali::Vector< float > *)jarg1;
46835   arg2 = (Dali::Vector< float >::SizeType)jarg2;
46836   temp3 = (Dali::Vector< float >::ItemType)jarg3;
46837   arg3 = &temp3;
46838   {
46839     try {
46840       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
46841     } catch (std::out_of_range& e) {
46842       {
46843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46844       };
46845     } catch (std::exception& e) {
46846       {
46847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46848       };
46849     } catch (...) {
46850       {
46851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46852       };
46853     }
46854   }
46855 }
46856
46857
46858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
46859   void * jresult ;
46860   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46861   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
46862   Dali::Vector< float >::Iterator result;
46863
46864   arg1 = (Dali::Vector< float > *)jarg1;
46865   arg2 = (Dali::Vector< float >::Iterator)jarg2;
46866   {
46867     try {
46868       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
46869     } catch (std::out_of_range& e) {
46870       {
46871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46872       };
46873     } catch (std::exception& e) {
46874       {
46875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46876       };
46877     } catch (...) {
46878       {
46879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46880       };
46881     }
46882   }
46883   jresult = (void *)result;
46884   return jresult;
46885 }
46886
46887
46888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46889   void * jresult ;
46890   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46891   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
46892   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
46893   Dali::Vector< float >::Iterator result;
46894
46895   arg1 = (Dali::Vector< float > *)jarg1;
46896   arg2 = (Dali::Vector< float >::Iterator)jarg2;
46897   arg3 = (Dali::Vector< float >::Iterator)jarg3;
46898   {
46899     try {
46900       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
46901     } catch (std::out_of_range& e) {
46902       {
46903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46904       };
46905     } catch (std::exception& e) {
46906       {
46907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46908       };
46909     } catch (...) {
46910       {
46911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46912       };
46913     }
46914   }
46915   jresult = (void *)result;
46916   return jresult;
46917 }
46918
46919
46920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
46921   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46922   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
46923
46924   arg1 = (Dali::Vector< float > *)jarg1;
46925   arg2 = (Dali::Vector< float >::Iterator)jarg2;
46926   {
46927     try {
46928       (arg1)->Remove(arg2);
46929     } catch (std::out_of_range& e) {
46930       {
46931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46932       };
46933     } catch (std::exception& e) {
46934       {
46935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46936       };
46937     } catch (...) {
46938       {
46939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46940       };
46941     }
46942   }
46943 }
46944
46945
46946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
46947   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46948   Dali::Vector< float > *arg2 = 0 ;
46949
46950   arg1 = (Dali::Vector< float > *)jarg1;
46951   arg2 = (Dali::Vector< float > *)jarg2;
46952   if (!arg2) {
46953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
46954     return ;
46955   }
46956   {
46957     try {
46958       (arg1)->Swap(*arg2);
46959     } catch (std::out_of_range& e) {
46960       {
46961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46962       };
46963     } catch (std::exception& e) {
46964       {
46965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46966       };
46967     } catch (...) {
46968       {
46969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46970       };
46971     }
46972   }
46973 }
46974
46975
46976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
46977   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46978
46979   arg1 = (Dali::Vector< float > *)jarg1;
46980   {
46981     try {
46982       (arg1)->Clear();
46983     } catch (std::out_of_range& e) {
46984       {
46985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46986       };
46987     } catch (std::exception& e) {
46988       {
46989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46990       };
46991     } catch (...) {
46992       {
46993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46994       };
46995     }
46996   }
46997 }
46998
46999
47000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47001   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47002
47003   arg1 = (Dali::Vector< float > *)jarg1;
47004   {
47005     try {
47006       (arg1)->Release();
47007     } catch (std::out_of_range& e) {
47008       {
47009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47010       };
47011     } catch (std::exception& e) {
47012       {
47013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47014       };
47015     } catch (...) {
47016       {
47017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47018       };
47019     }
47020   }
47021 }
47022
47023
47024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47025   int jresult ;
47026   int result;
47027
47028   result = (int)Dali::Vector< unsigned char >::BaseType;
47029   jresult = (int)result;
47030   return jresult;
47031 }
47032
47033
47034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47035   void * jresult ;
47036   Dali::Vector< unsigned char > *result = 0 ;
47037
47038   {
47039     try {
47040       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47041     } catch (std::out_of_range& e) {
47042       {
47043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47044       };
47045     } catch (std::exception& e) {
47046       {
47047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47048       };
47049     } catch (...) {
47050       {
47051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47052       };
47053     }
47054   }
47055   jresult = (void *)result;
47056   return jresult;
47057 }
47058
47059
47060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47061   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47062
47063   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47064   {
47065     try {
47066       delete arg1;
47067     } catch (std::out_of_range& e) {
47068       {
47069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47070       };
47071     } catch (std::exception& e) {
47072       {
47073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47074       };
47075     } catch (...) {
47076       {
47077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47078       };
47079     }
47080   }
47081 }
47082
47083
47084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47085   void * jresult ;
47086   Dali::Vector< unsigned char > *arg1 = 0 ;
47087   Dali::Vector< unsigned char > *result = 0 ;
47088
47089   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47090   if (!arg1) {
47091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47092     return 0;
47093   }
47094   {
47095     try {
47096       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47097     } catch (std::out_of_range& e) {
47098       {
47099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47100       };
47101     } catch (std::exception& e) {
47102       {
47103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47104       };
47105     } catch (...) {
47106       {
47107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47108       };
47109     }
47110   }
47111   jresult = (void *)result;
47112   return jresult;
47113 }
47114
47115
47116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47117   void * jresult ;
47118   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47119   Dali::Vector< unsigned char > *arg2 = 0 ;
47120   Dali::Vector< unsigned char > *result = 0 ;
47121
47122   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47123   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47124   if (!arg2) {
47125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47126     return 0;
47127   }
47128   {
47129     try {
47130       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47131     } catch (std::out_of_range& e) {
47132       {
47133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47134       };
47135     } catch (std::exception& e) {
47136       {
47137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47138       };
47139     } catch (...) {
47140       {
47141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47142       };
47143     }
47144   }
47145   jresult = (void *)result;
47146   return jresult;
47147 }
47148
47149
47150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47151   void * jresult ;
47152   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47153   Dali::Vector< unsigned char >::Iterator result;
47154
47155   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47156   {
47157     try {
47158       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47159     } catch (std::out_of_range& e) {
47160       {
47161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47162       };
47163     } catch (std::exception& e) {
47164       {
47165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47166       };
47167     } catch (...) {
47168       {
47169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47170       };
47171     }
47172   }
47173   jresult = (void *)result;
47174   return jresult;
47175 }
47176
47177
47178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47179   void * jresult ;
47180   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47181   Dali::Vector< unsigned char >::Iterator result;
47182
47183   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47184   {
47185     try {
47186       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47187     } catch (std::out_of_range& e) {
47188       {
47189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47190       };
47191     } catch (std::exception& e) {
47192       {
47193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47194       };
47195     } catch (...) {
47196       {
47197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47198       };
47199     }
47200   }
47201   jresult = (void *)result;
47202   return jresult;
47203 }
47204
47205
47206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47207   void * jresult ;
47208   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47209   Dali::Vector< unsigned char >::SizeType arg2 ;
47210   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47211
47212   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47213   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47214   {
47215     try {
47216       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47217     } catch (std::out_of_range& e) {
47218       {
47219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47220       };
47221     } catch (std::exception& e) {
47222       {
47223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47224       };
47225     } catch (...) {
47226       {
47227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47228       };
47229     }
47230   }
47231   jresult = (void *)result;
47232   return jresult;
47233 }
47234
47235
47236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47237   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47238   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47239   Dali::Vector< unsigned char >::ItemType temp2 ;
47240
47241   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47242   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47243   arg2 = &temp2;
47244   {
47245     try {
47246       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47247     } catch (std::out_of_range& e) {
47248       {
47249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47250       };
47251     } catch (std::exception& e) {
47252       {
47253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47254       };
47255     } catch (...) {
47256       {
47257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47258       };
47259     }
47260   }
47261 }
47262
47263
47264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47265   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47266   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47267   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47268   Dali::Vector< unsigned char >::ItemType temp3 ;
47269
47270   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47271   arg2 = jarg2;
47272   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47273   arg3 = &temp3;
47274   {
47275     try {
47276       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47277     } catch (std::out_of_range& e) {
47278       {
47279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47280       };
47281     } catch (std::exception& e) {
47282       {
47283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47284       };
47285     } catch (...) {
47286       {
47287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47288       };
47289     }
47290   }
47291
47292
47293 }
47294
47295
47296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47297   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47298   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47299   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47300   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47301
47302   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47303   arg2 = jarg2;
47304   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47305   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47306   {
47307     try {
47308       (arg1)->Insert(arg2,arg3,arg4);
47309     } catch (std::out_of_range& e) {
47310       {
47311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47312       };
47313     } catch (std::exception& e) {
47314       {
47315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47316       };
47317     } catch (...) {
47318       {
47319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47320       };
47321     }
47322   }
47323
47324
47325 }
47326
47327
47328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47329   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47330   Dali::Vector< unsigned char >::SizeType arg2 ;
47331
47332   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47333   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47334   {
47335     try {
47336       (arg1)->Reserve(arg2);
47337     } catch (std::out_of_range& e) {
47338       {
47339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47340       };
47341     } catch (std::exception& e) {
47342       {
47343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47344       };
47345     } catch (...) {
47346       {
47347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47348       };
47349     }
47350   }
47351 }
47352
47353
47354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47355   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47356   Dali::Vector< unsigned char >::SizeType arg2 ;
47357
47358   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47359   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47360   {
47361     try {
47362       (arg1)->Resize(arg2);
47363     } catch (std::out_of_range& e) {
47364       {
47365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47366       };
47367     } catch (std::exception& e) {
47368       {
47369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47370       };
47371     } catch (...) {
47372       {
47373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47374       };
47375     }
47376   }
47377 }
47378
47379
47380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47381   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47382   Dali::Vector< unsigned char >::SizeType arg2 ;
47383   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47384   Dali::Vector< unsigned char >::ItemType temp3 ;
47385
47386   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47387   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47388   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47389   arg3 = &temp3;
47390   {
47391     try {
47392       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47393     } catch (std::out_of_range& e) {
47394       {
47395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47396       };
47397     } catch (std::exception& e) {
47398       {
47399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47400       };
47401     } catch (...) {
47402       {
47403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47404       };
47405     }
47406   }
47407 }
47408
47409
47410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
47411   void * jresult ;
47412   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47413   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47414   Dali::Vector< unsigned char >::Iterator result;
47415
47416   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47417   arg2 = jarg2;
47418   {
47419     try {
47420       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
47421     } catch (std::out_of_range& e) {
47422       {
47423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47424       };
47425     } catch (std::exception& e) {
47426       {
47427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47428       };
47429     } catch (...) {
47430       {
47431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47432       };
47433     }
47434   }
47435   jresult = (void *)result;
47436
47437
47438   return jresult;
47439 }
47440
47441
47442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
47443   void * jresult ;
47444   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47445   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47446   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47447   Dali::Vector< unsigned char >::Iterator result;
47448
47449   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47450   arg2 = jarg2;
47451   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47452   {
47453     try {
47454       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
47455     } catch (std::out_of_range& e) {
47456       {
47457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47458       };
47459     } catch (std::exception& e) {
47460       {
47461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47462       };
47463     } catch (...) {
47464       {
47465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47466       };
47467     }
47468   }
47469   jresult = (void *)result;
47470
47471
47472   return jresult;
47473 }
47474
47475
47476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
47477   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47478   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47479
47480   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47481   arg2 = jarg2;
47482   {
47483     try {
47484       (arg1)->Remove(arg2);
47485     } catch (std::out_of_range& e) {
47486       {
47487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47488       };
47489     } catch (std::exception& e) {
47490       {
47491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47492       };
47493     } catch (...) {
47494       {
47495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47496       };
47497     }
47498   }
47499
47500
47501 }
47502
47503
47504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
47505   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47506   Dali::Vector< unsigned char > *arg2 = 0 ;
47507
47508   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47509   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47510   if (!arg2) {
47511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
47512     return ;
47513   }
47514   {
47515     try {
47516       (arg1)->Swap(*arg2);
47517     } catch (std::out_of_range& e) {
47518       {
47519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47520       };
47521     } catch (std::exception& e) {
47522       {
47523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47524       };
47525     } catch (...) {
47526       {
47527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47528       };
47529     }
47530   }
47531 }
47532
47533
47534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
47535   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47536
47537   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47538   {
47539     try {
47540       (arg1)->Clear();
47541     } catch (std::out_of_range& e) {
47542       {
47543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47544       };
47545     } catch (std::exception& e) {
47546       {
47547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47548       };
47549     } catch (...) {
47550       {
47551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47552       };
47553     }
47554   }
47555 }
47556
47557
47558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
47559   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47560
47561   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47562   {
47563     try {
47564       (arg1)->Release();
47565     } catch (std::out_of_range& e) {
47566       {
47567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47568       };
47569     } catch (std::exception& e) {
47570       {
47571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47572       };
47573     } catch (...) {
47574       {
47575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47576       };
47577     }
47578   }
47579 }
47580
47581
47582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
47583   int jresult ;
47584   int result;
47585
47586   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
47587   jresult = (int)result;
47588   return jresult;
47589 }
47590
47591
47592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
47593   void * jresult ;
47594   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
47595
47596   {
47597     try {
47598       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
47599     } catch (std::out_of_range& e) {
47600       {
47601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47602       };
47603     } catch (std::exception& e) {
47604       {
47605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47606       };
47607     } catch (...) {
47608       {
47609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47610       };
47611     }
47612   }
47613   jresult = (void *)result;
47614   return jresult;
47615 }
47616
47617
47618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
47619   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47620
47621   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47622   {
47623     try {
47624       delete arg1;
47625     } catch (std::out_of_range& e) {
47626       {
47627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47628       };
47629     } catch (std::exception& e) {
47630       {
47631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47632       };
47633     } catch (...) {
47634       {
47635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47636       };
47637     }
47638   }
47639 }
47640
47641
47642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
47643   void * jresult ;
47644   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
47645   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
47646
47647   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47648   if (!arg1) {
47649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
47650     return 0;
47651   }
47652   {
47653     try {
47654       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
47655     } catch (std::out_of_range& e) {
47656       {
47657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47658       };
47659     } catch (std::exception& e) {
47660       {
47661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47662       };
47663     } catch (...) {
47664       {
47665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47666       };
47667     }
47668   }
47669   jresult = (void *)result;
47670   return jresult;
47671 }
47672
47673
47674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
47675   void * jresult ;
47676   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47677   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
47678   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
47679
47680   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47681   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
47682   if (!arg2) {
47683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
47684     return 0;
47685   }
47686   {
47687     try {
47688       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
47689     } catch (std::out_of_range& e) {
47690       {
47691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47692       };
47693     } catch (std::exception& e) {
47694       {
47695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47696       };
47697     } catch (...) {
47698       {
47699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47700       };
47701     }
47702   }
47703   jresult = (void *)result;
47704   return jresult;
47705 }
47706
47707
47708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
47709   void * jresult ;
47710   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47711   Dali::Vector< Dali::Uint16Pair >::Iterator result;
47712
47713   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47714   {
47715     try {
47716       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
47717     } catch (std::out_of_range& e) {
47718       {
47719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47720       };
47721     } catch (std::exception& e) {
47722       {
47723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47724       };
47725     } catch (...) {
47726       {
47727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47728       };
47729     }
47730   }
47731   jresult = (void *)result;
47732   return jresult;
47733 }
47734
47735
47736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
47737   void * jresult ;
47738   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47739   Dali::Vector< Dali::Uint16Pair >::Iterator result;
47740
47741   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47742   {
47743     try {
47744       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
47745     } catch (std::out_of_range& e) {
47746       {
47747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47748       };
47749     } catch (std::exception& e) {
47750       {
47751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47752       };
47753     } catch (...) {
47754       {
47755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47756       };
47757     }
47758   }
47759   jresult = (void *)result;
47760   return jresult;
47761 }
47762
47763
47764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47765   void * jresult ;
47766   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47767   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
47768   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
47769
47770   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47771   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
47772   {
47773     try {
47774       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
47775     } catch (std::out_of_range& e) {
47776       {
47777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47778       };
47779     } catch (std::exception& e) {
47780       {
47781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47782       };
47783     } catch (...) {
47784       {
47785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47786       };
47787     }
47788   }
47789   jresult = (void *)result;
47790   return jresult;
47791 }
47792
47793
47794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
47795   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47796   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
47797
47798   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47799   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
47800   if (!arg2) {
47801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
47802     return ;
47803   }
47804   {
47805     try {
47806       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
47807     } catch (std::out_of_range& e) {
47808       {
47809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47810       };
47811     } catch (std::exception& e) {
47812       {
47813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47814       };
47815     } catch (...) {
47816       {
47817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47818       };
47819     }
47820   }
47821 }
47822
47823
47824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
47825   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47826   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
47827   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
47828
47829   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47830   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
47831   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
47832   if (!arg3) {
47833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
47834     return ;
47835   }
47836   {
47837     try {
47838       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
47839     } catch (std::out_of_range& e) {
47840       {
47841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47842       };
47843     } catch (std::exception& e) {
47844       {
47845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47846       };
47847     } catch (...) {
47848       {
47849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47850       };
47851     }
47852   }
47853 }
47854
47855
47856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47857   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47858   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
47859   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
47860   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
47861
47862   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47863   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
47864   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
47865   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
47866   {
47867     try {
47868       (arg1)->Insert(arg2,arg3,arg4);
47869     } catch (std::out_of_range& e) {
47870       {
47871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47872       };
47873     } catch (std::exception& e) {
47874       {
47875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47876       };
47877     } catch (...) {
47878       {
47879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47880       };
47881     }
47882   }
47883 }
47884
47885
47886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
47887   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47888   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
47889
47890   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47891   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
47892   {
47893     try {
47894       (arg1)->Reserve(arg2);
47895     } catch (std::out_of_range& e) {
47896       {
47897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47898       };
47899     } catch (std::exception& e) {
47900       {
47901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47902       };
47903     } catch (...) {
47904       {
47905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47906       };
47907     }
47908   }
47909 }
47910
47911
47912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47913   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47914   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
47915
47916   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47917   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
47918   {
47919     try {
47920       (arg1)->Resize(arg2);
47921     } catch (std::out_of_range& e) {
47922       {
47923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47924       };
47925     } catch (std::exception& e) {
47926       {
47927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47928       };
47929     } catch (...) {
47930       {
47931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47932       };
47933     }
47934   }
47935 }
47936
47937
47938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
47939   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47940   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
47941   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
47942
47943   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47944   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
47945   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
47946   if (!arg3) {
47947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
47948     return ;
47949   }
47950   {
47951     try {
47952       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
47953     } catch (std::out_of_range& e) {
47954       {
47955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47956       };
47957     } catch (std::exception& e) {
47958       {
47959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47960       };
47961     } catch (...) {
47962       {
47963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47964       };
47965     }
47966   }
47967 }
47968
47969
47970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
47971   void * jresult ;
47972   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47973   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
47974   Dali::Vector< Dali::Uint16Pair >::Iterator result;
47975
47976   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47977   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
47978   {
47979     try {
47980       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
47981     } catch (std::out_of_range& e) {
47982       {
47983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47984       };
47985     } catch (std::exception& e) {
47986       {
47987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47988       };
47989     } catch (...) {
47990       {
47991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47992       };
47993     }
47994   }
47995   jresult = (void *)result;
47996   return jresult;
47997 }
47998
47999
48000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48001   void * jresult ;
48002   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48003   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48004   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48005   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48006
48007   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48008   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48009   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48010   {
48011     try {
48012       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48013     } catch (std::out_of_range& e) {
48014       {
48015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48016       };
48017     } catch (std::exception& e) {
48018       {
48019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48020       };
48021     } catch (...) {
48022       {
48023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48024       };
48025     }
48026   }
48027   jresult = (void *)result;
48028   return jresult;
48029 }
48030
48031
48032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48033   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48034   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48035
48036   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48037   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48038   {
48039     try {
48040       (arg1)->Remove(arg2);
48041     } catch (std::out_of_range& e) {
48042       {
48043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48044       };
48045     } catch (std::exception& e) {
48046       {
48047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48048       };
48049     } catch (...) {
48050       {
48051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48052       };
48053     }
48054   }
48055 }
48056
48057
48058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48059   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48060   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48061
48062   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48063   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48064   if (!arg2) {
48065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48066     return ;
48067   }
48068   {
48069     try {
48070       (arg1)->Swap(*arg2);
48071     } catch (std::out_of_range& e) {
48072       {
48073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48074       };
48075     } catch (std::exception& e) {
48076       {
48077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48078       };
48079     } catch (...) {
48080       {
48081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48082       };
48083     }
48084   }
48085 }
48086
48087
48088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48089   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48090
48091   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48092   {
48093     try {
48094       (arg1)->Clear();
48095     } catch (std::out_of_range& e) {
48096       {
48097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48098       };
48099     } catch (std::exception& e) {
48100       {
48101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48102       };
48103     } catch (...) {
48104       {
48105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48106       };
48107     }
48108   }
48109 }
48110
48111
48112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48113   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48114
48115   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48116   {
48117     try {
48118       (arg1)->Release();
48119     } catch (std::out_of_range& e) {
48120       {
48121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48122       };
48123     } catch (std::exception& e) {
48124       {
48125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48126       };
48127     } catch (...) {
48128       {
48129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48130       };
48131     }
48132   }
48133 }
48134
48135
48136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48137   void * jresult ;
48138   Dali::Signal< void () > *result = 0 ;
48139
48140   {
48141     try {
48142       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48143     } catch (std::out_of_range& e) {
48144       {
48145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48146       };
48147     } catch (std::exception& e) {
48148       {
48149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48150       };
48151     } catch (...) {
48152       {
48153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48154       };
48155     }
48156   }
48157   jresult = (void *)result;
48158   return jresult;
48159 }
48160
48161
48162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48163   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48164
48165   arg1 = (Dali::Signal< void () > *)jarg1;
48166   {
48167     try {
48168       delete arg1;
48169     } catch (std::out_of_range& e) {
48170       {
48171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48172       };
48173     } catch (std::exception& e) {
48174       {
48175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48176       };
48177     } catch (...) {
48178       {
48179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48180       };
48181     }
48182   }
48183 }
48184
48185
48186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48187   unsigned int jresult ;
48188   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48189   bool result;
48190
48191   arg1 = (Dali::Signal< void () > *)jarg1;
48192   {
48193     try {
48194       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48195     } catch (std::out_of_range& e) {
48196       {
48197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48198       };
48199     } catch (std::exception& e) {
48200       {
48201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48202       };
48203     } catch (...) {
48204       {
48205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48206       };
48207     }
48208   }
48209   jresult = result;
48210   return jresult;
48211 }
48212
48213
48214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48215   unsigned long jresult ;
48216   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48217   std::size_t result;
48218
48219   arg1 = (Dali::Signal< void () > *)jarg1;
48220   {
48221     try {
48222       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48223     } catch (std::out_of_range& e) {
48224       {
48225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48226       };
48227     } catch (std::exception& e) {
48228       {
48229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48230       };
48231     } catch (...) {
48232       {
48233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48234       };
48235     }
48236   }
48237   jresult = (unsigned long)result;
48238   return jresult;
48239 }
48240
48241
48242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48243   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48244   void (*arg2)() = (void (*)()) 0 ;
48245
48246   arg1 = (Dali::Signal< void () > *)jarg1;
48247   arg2 = (void (*)())jarg2;
48248   {
48249     try {
48250       (arg1)->Connect(arg2);
48251     } catch (std::out_of_range& e) {
48252       {
48253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48254       };
48255     } catch (std::exception& e) {
48256       {
48257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48258       };
48259     } catch (...) {
48260       {
48261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48262       };
48263     }
48264   }
48265 }
48266
48267
48268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48269   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48270   void (*arg2)() = (void (*)()) 0 ;
48271
48272   arg1 = (Dali::Signal< void () > *)jarg1;
48273   arg2 = (void (*)())jarg2;
48274   {
48275     try {
48276       (arg1)->Disconnect(arg2);
48277     } catch (std::out_of_range& e) {
48278       {
48279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48280       };
48281     } catch (std::exception& e) {
48282       {
48283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48284       };
48285     } catch (...) {
48286       {
48287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48288       };
48289     }
48290   }
48291 }
48292
48293
48294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48295   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48296   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48297   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48298
48299   arg1 = (Dali::Signal< void () > *)jarg1;
48300   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48301   arg3 = (Dali::FunctorDelegate *)jarg3;
48302   {
48303     try {
48304       (arg1)->Connect(arg2,arg3);
48305     } catch (std::out_of_range& e) {
48306       {
48307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48308       };
48309     } catch (std::exception& e) {
48310       {
48311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48312       };
48313     } catch (...) {
48314       {
48315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48316       };
48317     }
48318   }
48319 }
48320
48321
48322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48323   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48324
48325   arg1 = (Dali::Signal< void () > *)jarg1;
48326   {
48327     try {
48328       (arg1)->Emit();
48329     } catch (std::out_of_range& e) {
48330       {
48331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48332       };
48333     } catch (std::exception& e) {
48334       {
48335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48336       };
48337     } catch (...) {
48338       {
48339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48340       };
48341     }
48342   }
48343 }
48344
48345
48346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BoolSignal() {
48347   void * jresult ;
48348   Dali::Signal< bool () > *result = 0 ;
48349
48350   {
48351     try {
48352       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
48353     } catch (std::out_of_range& e) {
48354       {
48355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48356       };
48357     } catch (std::exception& e) {
48358       {
48359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48360       };
48361     } catch (...) {
48362       {
48363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48364       };
48365     }
48366   }
48367   jresult = (void *)result;
48368   return jresult;
48369 }
48370
48371
48372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BoolSignal(void * jarg1) {
48373   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48374
48375   arg1 = (Dali::Signal< bool () > *)jarg1;
48376   {
48377     try {
48378       delete arg1;
48379     } catch (std::out_of_range& e) {
48380       {
48381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48382       };
48383     } catch (std::exception& e) {
48384       {
48385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48386       };
48387     } catch (...) {
48388       {
48389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48390       };
48391     }
48392   }
48393 }
48394
48395
48396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BoolSignal_Empty(void * jarg1) {
48397   unsigned int jresult ;
48398   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48399   bool result;
48400
48401   arg1 = (Dali::Signal< bool () > *)jarg1;
48402   {
48403     try {
48404       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
48405     } catch (std::out_of_range& e) {
48406       {
48407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48408       };
48409     } catch (std::exception& e) {
48410       {
48411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48412       };
48413     } catch (...) {
48414       {
48415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48416       };
48417     }
48418   }
48419   jresult = result;
48420   return jresult;
48421 }
48422
48423
48424 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_BoolSignal_GetConnectionCount(void * jarg1) {
48425   unsigned long jresult ;
48426   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48427   std::size_t result;
48428
48429   arg1 = (Dali::Signal< bool () > *)jarg1;
48430   {
48431     try {
48432       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
48433     } catch (std::out_of_range& e) {
48434       {
48435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48436       };
48437     } catch (std::exception& e) {
48438       {
48439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48440       };
48441     } catch (...) {
48442       {
48443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48444       };
48445     }
48446   }
48447   jresult = (unsigned long)result;
48448   return jresult;
48449 }
48450
48451
48452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BoolSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48453   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48454   bool (*arg2)() = (bool (*)()) 0 ;
48455
48456   arg1 = (Dali::Signal< bool () > *)jarg1;
48457   arg2 = (bool (*)())jarg2;
48458   {
48459     try {
48460       (arg1)->Connect(arg2);
48461     } catch (std::out_of_range& e) {
48462       {
48463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48464       };
48465     } catch (std::exception& e) {
48466       {
48467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48468       };
48469     } catch (...) {
48470       {
48471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48472       };
48473     }
48474   }
48475 }
48476
48477
48478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BoolSignal_Disconnect(void * jarg1, void * jarg2) {
48479   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48480   bool (*arg2)() = (bool (*)()) 0 ;
48481
48482   arg1 = (Dali::Signal< bool () > *)jarg1;
48483   arg2 = (bool (*)())jarg2;
48484   {
48485     try {
48486       (arg1)->Disconnect(arg2);
48487     } catch (std::out_of_range& e) {
48488       {
48489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48490       };
48491     } catch (std::exception& e) {
48492       {
48493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48494       };
48495     } catch (...) {
48496       {
48497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48498       };
48499     }
48500   }
48501 }
48502
48503
48504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BoolSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48505   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48506   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48507   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48508
48509   arg1 = (Dali::Signal< bool () > *)jarg1;
48510   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48511   arg3 = (Dali::FunctorDelegate *)jarg3;
48512   {
48513     try {
48514       (arg1)->Connect(arg2,arg3);
48515     } catch (std::out_of_range& e) {
48516       {
48517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48518       };
48519     } catch (std::exception& e) {
48520       {
48521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48522       };
48523     } catch (...) {
48524       {
48525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48526       };
48527     }
48528   }
48529 }
48530
48531
48532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BoolSignal_Emit(void * jarg1) {
48533   unsigned int jresult ;
48534   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48535   bool result;
48536
48537   arg1 = (Dali::Signal< bool () > *)jarg1;
48538   {
48539     try {
48540       result = (bool)(arg1)->Emit();
48541     } catch (std::out_of_range& e) {
48542       {
48543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48544       };
48545     } catch (std::exception& e) {
48546       {
48547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48548       };
48549     } catch (...) {
48550       {
48551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48552       };
48553     }
48554   }
48555   jresult = result;
48556   return jresult;
48557 }
48558
48559
48560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48561   unsigned int jresult ;
48562   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48563   bool result;
48564
48565   arg1 = (Dali::Signal< void (float) > *)jarg1;
48566   {
48567     try {
48568       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48569     } catch (std::out_of_range& e) {
48570       {
48571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48572       };
48573     } catch (std::exception& e) {
48574       {
48575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48576       };
48577     } catch (...) {
48578       {
48579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48580       };
48581     }
48582   }
48583   jresult = result;
48584   return jresult;
48585 }
48586
48587
48588 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48589   unsigned long jresult ;
48590   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48591   std::size_t result;
48592
48593   arg1 = (Dali::Signal< void (float) > *)jarg1;
48594   {
48595     try {
48596       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48597     } catch (std::out_of_range& e) {
48598       {
48599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48600       };
48601     } catch (std::exception& e) {
48602       {
48603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48604       };
48605     } catch (...) {
48606       {
48607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48608       };
48609     }
48610   }
48611   jresult = (unsigned long)result;
48612   return jresult;
48613 }
48614
48615
48616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
48617   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48618   void (*arg2)(float) = (void (*)(float)) 0 ;
48619
48620   arg1 = (Dali::Signal< void (float) > *)jarg1;
48621   arg2 = (void (*)(float))jarg2;
48622   {
48623     try {
48624       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
48625     } catch (std::out_of_range& e) {
48626       {
48627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48628       };
48629     } catch (std::exception& e) {
48630       {
48631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48632       };
48633     } catch (...) {
48634       {
48635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48636       };
48637     }
48638   }
48639 }
48640
48641
48642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
48643   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48644   void (*arg2)(float) = (void (*)(float)) 0 ;
48645
48646   arg1 = (Dali::Signal< void (float) > *)jarg1;
48647   arg2 = (void (*)(float))jarg2;
48648   {
48649     try {
48650       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
48651     } catch (std::out_of_range& e) {
48652       {
48653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48654       };
48655     } catch (std::exception& e) {
48656       {
48657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48658       };
48659     } catch (...) {
48660       {
48661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48662       };
48663     }
48664   }
48665 }
48666
48667
48668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
48669   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48670   float arg2 ;
48671
48672   arg1 = (Dali::Signal< void (float) > *)jarg1;
48673   arg2 = (float)jarg2;
48674   {
48675     try {
48676       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
48677     } catch (std::out_of_range& e) {
48678       {
48679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48680       };
48681     } catch (std::exception& e) {
48682       {
48683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48684       };
48685     } catch (...) {
48686       {
48687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48688       };
48689     }
48690   }
48691 }
48692
48693
48694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
48695   void * jresult ;
48696   Dali::Signal< void (float) > *result = 0 ;
48697
48698   {
48699     try {
48700       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
48701     } catch (std::out_of_range& e) {
48702       {
48703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48704       };
48705     } catch (std::exception& e) {
48706       {
48707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48708       };
48709     } catch (...) {
48710       {
48711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48712       };
48713     }
48714   }
48715   jresult = (void *)result;
48716   return jresult;
48717 }
48718
48719
48720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
48721   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48722
48723   arg1 = (Dali::Signal< void (float) > *)jarg1;
48724   {
48725     try {
48726       delete arg1;
48727     } catch (std::out_of_range& e) {
48728       {
48729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48730       };
48731     } catch (std::exception& e) {
48732       {
48733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48734       };
48735     } catch (...) {
48736       {
48737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48738       };
48739     }
48740   }
48741 }
48742
48743
48744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
48745   unsigned int jresult ;
48746   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48747   bool result;
48748
48749   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48750   {
48751     try {
48752       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48753     } catch (std::out_of_range& e) {
48754       {
48755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48756       };
48757     } catch (std::exception& e) {
48758       {
48759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48760       };
48761     } catch (...) {
48762       {
48763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48764       };
48765     }
48766   }
48767   jresult = result;
48768   return jresult;
48769 }
48770
48771
48772 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
48773   unsigned long jresult ;
48774   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48775   std::size_t result;
48776
48777   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48778   {
48779     try {
48780       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48781     } catch (std::out_of_range& e) {
48782       {
48783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48784       };
48785     } catch (std::exception& e) {
48786       {
48787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48788       };
48789     } catch (...) {
48790       {
48791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48792       };
48793     }
48794   }
48795   jresult = (unsigned long)result;
48796   return jresult;
48797 }
48798
48799
48800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
48801   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48802   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
48803
48804   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48805   arg2 = (void (*)(Dali::BaseHandle))jarg2;
48806   {
48807     try {
48808       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
48809     } catch (std::out_of_range& e) {
48810       {
48811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48812       };
48813     } catch (std::exception& e) {
48814       {
48815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48816       };
48817     } catch (...) {
48818       {
48819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48820       };
48821     }
48822   }
48823 }
48824
48825
48826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
48827   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48828   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
48829
48830   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48831   arg2 = (void (*)(Dali::BaseHandle))jarg2;
48832   {
48833     try {
48834       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
48835     } catch (std::out_of_range& e) {
48836       {
48837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48838       };
48839     } catch (std::exception& e) {
48840       {
48841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48842       };
48843     } catch (...) {
48844       {
48845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48846       };
48847     }
48848   }
48849 }
48850
48851
48852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
48853   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48854   Dali::BaseHandle arg2 ;
48855   Dali::BaseHandle *argp2 ;
48856
48857   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48858   argp2 = (Dali::BaseHandle *)jarg2;
48859   if (!argp2) {
48860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48861     return ;
48862   }
48863   arg2 = *argp2;
48864   {
48865     try {
48866       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
48867     } catch (std::out_of_range& e) {
48868       {
48869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48870       };
48871     } catch (std::exception& e) {
48872       {
48873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48874       };
48875     } catch (...) {
48876       {
48877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48878       };
48879     }
48880   }
48881 }
48882
48883
48884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
48885   void * jresult ;
48886   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
48887
48888   {
48889     try {
48890       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
48891     } catch (std::out_of_range& e) {
48892       {
48893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48894       };
48895     } catch (std::exception& e) {
48896       {
48897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48898       };
48899     } catch (...) {
48900       {
48901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48902       };
48903     }
48904   }
48905   jresult = (void *)result;
48906   return jresult;
48907 }
48908
48909
48910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
48911   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48912
48913   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48914   {
48915     try {
48916       delete arg1;
48917     } catch (std::out_of_range& e) {
48918       {
48919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48920       };
48921     } catch (std::exception& e) {
48922       {
48923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48924       };
48925     } catch (...) {
48926       {
48927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48928       };
48929     }
48930   }
48931 }
48932
48933
48934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
48935   unsigned int jresult ;
48936   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
48937   bool result;
48938
48939   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
48940   {
48941     try {
48942       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
48943     } catch (std::out_of_range& e) {
48944       {
48945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48946       };
48947     } catch (std::exception& e) {
48948       {
48949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48950       };
48951     } catch (...) {
48952       {
48953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48954       };
48955     }
48956   }
48957   jresult = result;
48958   return jresult;
48959 }
48960
48961
48962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
48963   unsigned long jresult ;
48964   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
48965   std::size_t result;
48966
48967   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
48968   {
48969     try {
48970       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
48971     } catch (std::out_of_range& e) {
48972       {
48973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48974       };
48975     } catch (std::exception& e) {
48976       {
48977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48978       };
48979     } catch (...) {
48980       {
48981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48982       };
48983     }
48984   }
48985   jresult = (unsigned long)result;
48986   return jresult;
48987 }
48988
48989
48990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
48991   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
48992   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
48993
48994   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
48995   arg2 = (void (*)(Dali::RefObject const *))jarg2;
48996   {
48997     try {
48998       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
48999     } catch (std::out_of_range& e) {
49000       {
49001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49002       };
49003     } catch (std::exception& e) {
49004       {
49005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49006       };
49007     } catch (...) {
49008       {
49009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49010       };
49011     }
49012   }
49013 }
49014
49015
49016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49017   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49018   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49019
49020   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49021   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49022   {
49023     try {
49024       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49025     } catch (std::out_of_range& e) {
49026       {
49027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49028       };
49029     } catch (std::exception& e) {
49030       {
49031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49032       };
49033     } catch (...) {
49034       {
49035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49036       };
49037     }
49038   }
49039 }
49040
49041
49042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49043   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49044   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49045
49046   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49047   arg2 = (Dali::RefObject *)jarg2;
49048   {
49049     try {
49050       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49051     } catch (std::out_of_range& e) {
49052       {
49053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49054       };
49055     } catch (std::exception& e) {
49056       {
49057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49058       };
49059     } catch (...) {
49060       {
49061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49062       };
49063     }
49064   }
49065 }
49066
49067
49068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49069   void * jresult ;
49070   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49071
49072   {
49073     try {
49074       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49075     } catch (std::out_of_range& e) {
49076       {
49077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49078       };
49079     } catch (std::exception& e) {
49080       {
49081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49082       };
49083     } catch (...) {
49084       {
49085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49086       };
49087     }
49088   }
49089   jresult = (void *)result;
49090   return jresult;
49091 }
49092
49093
49094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49095   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49096
49097   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49098   {
49099     try {
49100       delete arg1;
49101     } catch (std::out_of_range& e) {
49102       {
49103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49104       };
49105     } catch (std::exception& e) {
49106       {
49107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49108       };
49109     } catch (...) {
49110       {
49111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49112       };
49113     }
49114   }
49115 }
49116
49117
49118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49119   unsigned int jresult ;
49120   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49121   bool result;
49122
49123   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49124   {
49125     try {
49126       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49127     } catch (std::out_of_range& e) {
49128       {
49129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49130       };
49131     } catch (std::exception& e) {
49132       {
49133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49134       };
49135     } catch (...) {
49136       {
49137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49138       };
49139     }
49140   }
49141   jresult = result;
49142   return jresult;
49143 }
49144
49145
49146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49147   unsigned long jresult ;
49148   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49149   std::size_t result;
49150
49151   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49152   {
49153     try {
49154       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49155     } catch (std::out_of_range& e) {
49156       {
49157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49158       };
49159     } catch (std::exception& e) {
49160       {
49161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49162       };
49163     } catch (...) {
49164       {
49165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49166       };
49167     }
49168   }
49169   jresult = (unsigned long)result;
49170   return jresult;
49171 }
49172
49173
49174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49175   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49176   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49177
49178   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49179   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49180   {
49181     try {
49182       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49183     } catch (std::out_of_range& e) {
49184       {
49185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49186       };
49187     } catch (std::exception& e) {
49188       {
49189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49190       };
49191     } catch (...) {
49192       {
49193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49194       };
49195     }
49196   }
49197 }
49198
49199
49200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49201   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49202   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49203
49204   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49205   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49206   {
49207     try {
49208       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49209     } catch (std::out_of_range& e) {
49210       {
49211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49212       };
49213     } catch (std::exception& e) {
49214       {
49215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49216       };
49217     } catch (...) {
49218       {
49219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49220       };
49221     }
49222   }
49223 }
49224
49225
49226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49227   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49228   Dali::PropertyNotification *arg2 = 0 ;
49229
49230   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49231   arg2 = (Dali::PropertyNotification *)jarg2;
49232   if (!arg2) {
49233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49234     return ;
49235   }
49236   {
49237     try {
49238       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49239     } catch (std::out_of_range& e) {
49240       {
49241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49242       };
49243     } catch (std::exception& e) {
49244       {
49245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49246       };
49247     } catch (...) {
49248       {
49249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49250       };
49251     }
49252   }
49253 }
49254
49255
49256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49257   void * jresult ;
49258   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49259
49260   {
49261     try {
49262       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49263     } catch (std::out_of_range& e) {
49264       {
49265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49266       };
49267     } catch (std::exception& e) {
49268       {
49269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49270       };
49271     } catch (...) {
49272       {
49273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49274       };
49275     }
49276   }
49277   jresult = (void *)result;
49278   return jresult;
49279 }
49280
49281
49282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49283   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49284
49285   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49286   {
49287     try {
49288       delete arg1;
49289     } catch (std::out_of_range& e) {
49290       {
49291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49292       };
49293     } catch (std::exception& e) {
49294       {
49295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49296       };
49297     } catch (...) {
49298       {
49299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49300       };
49301     }
49302   }
49303 }
49304
49305
49306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49307   unsigned int jresult ;
49308   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49309   bool result;
49310
49311   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49312   {
49313     try {
49314       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49315     } catch (std::out_of_range& e) {
49316       {
49317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49318       };
49319     } catch (std::exception& e) {
49320       {
49321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49322       };
49323     } catch (...) {
49324       {
49325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49326       };
49327     }
49328   }
49329   jresult = result;
49330   return jresult;
49331 }
49332
49333
49334 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49335   unsigned long jresult ;
49336   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49337   std::size_t result;
49338
49339   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49340   {
49341     try {
49342       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49343     } catch (std::out_of_range& e) {
49344       {
49345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49346       };
49347     } catch (std::exception& e) {
49348       {
49349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49350       };
49351     } catch (...) {
49352       {
49353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49354       };
49355     }
49356   }
49357   jresult = (unsigned long)result;
49358   return jresult;
49359 }
49360
49361
49362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49363   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49364   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49365
49366   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49367   arg2 = (void (*)(Dali::Image))jarg2;
49368   {
49369     try {
49370       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49371     } catch (std::out_of_range& e) {
49372       {
49373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49374       };
49375     } catch (std::exception& e) {
49376       {
49377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49378       };
49379     } catch (...) {
49380       {
49381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49382       };
49383     }
49384   }
49385 }
49386
49387
49388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49389   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49390   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49391
49392   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49393   arg2 = (void (*)(Dali::Image))jarg2;
49394   {
49395     try {
49396       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49397     } catch (std::out_of_range& e) {
49398       {
49399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49400       };
49401     } catch (std::exception& e) {
49402       {
49403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49404       };
49405     } catch (...) {
49406       {
49407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49408       };
49409     }
49410   }
49411 }
49412
49413
49414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49415   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49416   Dali::Image arg2 ;
49417   Dali::Image *argp2 ;
49418
49419   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49420   argp2 = (Dali::Image *)jarg2;
49421   if (!argp2) {
49422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49423     return ;
49424   }
49425   arg2 = *argp2;
49426   {
49427     try {
49428       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49429     } catch (std::out_of_range& e) {
49430       {
49431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49432       };
49433     } catch (std::exception& e) {
49434       {
49435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49436       };
49437     } catch (...) {
49438       {
49439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49440       };
49441     }
49442   }
49443 }
49444
49445
49446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49447   void * jresult ;
49448   Dali::Signal< void (Dali::Image) > *result = 0 ;
49449
49450   {
49451     try {
49452       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49453     } catch (std::out_of_range& e) {
49454       {
49455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49456       };
49457     } catch (std::exception& e) {
49458       {
49459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49460       };
49461     } catch (...) {
49462       {
49463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49464       };
49465     }
49466   }
49467   jresult = (void *)result;
49468   return jresult;
49469 }
49470
49471
49472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49473   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49474
49475   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49476   {
49477     try {
49478       delete arg1;
49479     } catch (std::out_of_range& e) {
49480       {
49481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49482       };
49483     } catch (std::exception& e) {
49484       {
49485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49486       };
49487     } catch (...) {
49488       {
49489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49490       };
49491     }
49492   }
49493 }
49494
49495
49496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49497   void * jresult ;
49498   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49499
49500   {
49501     try {
49502       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49503     } catch (std::out_of_range& e) {
49504       {
49505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49506       };
49507     } catch (std::exception& e) {
49508       {
49509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49510       };
49511     } catch (...) {
49512       {
49513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49514       };
49515     }
49516   }
49517   jresult = (void *)result;
49518   return jresult;
49519 }
49520
49521
49522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49523   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49524
49525   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49526   {
49527     try {
49528       delete arg1;
49529     } catch (std::out_of_range& e) {
49530       {
49531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49532       };
49533     } catch (std::exception& e) {
49534       {
49535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49536       };
49537     } catch (...) {
49538       {
49539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49540       };
49541     }
49542   }
49543 }
49544
49545
49546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49547   unsigned int jresult ;
49548   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49549   bool result;
49550
49551   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49552   {
49553     try {
49554       result = (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 *)arg1);
49555     } catch (std::out_of_range& e) {
49556       {
49557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49558       };
49559     } catch (std::exception& e) {
49560       {
49561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49562       };
49563     } catch (...) {
49564       {
49565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49566       };
49567     }
49568   }
49569   jresult = result;
49570   return jresult;
49571 }
49572
49573
49574 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49575   unsigned long jresult ;
49576   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49577   std::size_t result;
49578
49579   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49580   {
49581     try {
49582       result = 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 *)arg1);
49583     } catch (std::out_of_range& e) {
49584       {
49585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49586       };
49587     } catch (std::exception& e) {
49588       {
49589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49590       };
49591     } catch (...) {
49592       {
49593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49594       };
49595     }
49596   }
49597   jresult = (unsigned long)result;
49598   return jresult;
49599 }
49600
49601
49602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49603   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49604   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49605
49606   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49607   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49608   {
49609     try {
49610       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49611     } catch (std::out_of_range& e) {
49612       {
49613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49614       };
49615     } catch (std::exception& e) {
49616       {
49617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49618       };
49619     } catch (...) {
49620       {
49621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49622       };
49623     }
49624   }
49625 }
49626
49627
49628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49629   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49630   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49631
49632   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49633   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49634   {
49635     try {
49636       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49637     } catch (std::out_of_range& e) {
49638       {
49639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49640       };
49641     } catch (std::exception& e) {
49642       {
49643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49644       };
49645     } catch (...) {
49646       {
49647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49648       };
49649     }
49650   }
49651 }
49652
49653
49654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49655   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49656   Dali::Actor arg2 ;
49657   Dali::LongPressGesture *arg3 = 0 ;
49658   Dali::Actor *argp2 ;
49659
49660   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49661   argp2 = (Dali::Actor *)jarg2;
49662   if (!argp2) {
49663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49664     return ;
49665   }
49666   arg2 = *argp2;
49667   arg3 = (Dali::LongPressGesture *)jarg3;
49668   if (!arg3) {
49669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
49670     return ;
49671   }
49672   {
49673     try {
49674       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
49675     } catch (std::out_of_range& e) {
49676       {
49677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49678       };
49679     } catch (std::exception& e) {
49680       {
49681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49682       };
49683     } catch (...) {
49684       {
49685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49686       };
49687     }
49688   }
49689 }
49690
49691
49692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
49693   void * jresult ;
49694   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
49695
49696   {
49697     try {
49698       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
49699     } catch (std::out_of_range& e) {
49700       {
49701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49702       };
49703     } catch (std::exception& e) {
49704       {
49705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49706       };
49707     } catch (...) {
49708       {
49709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49710       };
49711     }
49712   }
49713   jresult = (void *)result;
49714   return jresult;
49715 }
49716
49717
49718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
49719   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49720
49721   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49722   {
49723     try {
49724       delete arg1;
49725     } catch (std::out_of_range& e) {
49726       {
49727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49728       };
49729     } catch (std::exception& e) {
49730       {
49731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49732       };
49733     } catch (...) {
49734       {
49735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49736       };
49737     }
49738   }
49739 }
49740
49741
49742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchEventSignal() {
49743   void * jresult ;
49744   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
49745
49746   {
49747     try {
49748       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
49749     } catch (std::out_of_range& e) {
49750       {
49751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49752       };
49753     } catch (std::exception& e) {
49754       {
49755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49756       };
49757     } catch (...) {
49758       {
49759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49760       };
49761     }
49762   }
49763   jresult = (void *)result;
49764   return jresult;
49765 }
49766
49767
49768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchEventSignal(void * jarg1) {
49769   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
49770
49771   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
49772   {
49773     try {
49774       delete arg1;
49775     } catch (std::out_of_range& e) {
49776       {
49777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49778       };
49779     } catch (std::exception& e) {
49780       {
49781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49782       };
49783     } catch (...) {
49784       {
49785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49786       };
49787     }
49788   }
49789 }
49790
49791
49792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
49793   unsigned int jresult ;
49794   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49795   bool result;
49796
49797   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49798   {
49799     try {
49800       result = (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 *)arg1);
49801     } catch (std::out_of_range& e) {
49802       {
49803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49804       };
49805     } catch (std::exception& e) {
49806       {
49807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49808       };
49809     } catch (...) {
49810       {
49811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49812       };
49813     }
49814   }
49815   jresult = result;
49816   return jresult;
49817 }
49818
49819
49820 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
49821   unsigned long jresult ;
49822   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49823   std::size_t result;
49824
49825   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49826   {
49827     try {
49828       result = 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 *)arg1);
49829     } catch (std::out_of_range& e) {
49830       {
49831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49832       };
49833     } catch (std::exception& e) {
49834       {
49835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49836       };
49837     } catch (...) {
49838       {
49839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49840       };
49841     }
49842   }
49843   jresult = (unsigned long)result;
49844   return jresult;
49845 }
49846
49847
49848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
49849   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49850   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
49851
49852   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49853   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
49854   {
49855     try {
49856       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49857     } catch (std::out_of_range& e) {
49858       {
49859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49860       };
49861     } catch (std::exception& e) {
49862       {
49863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49864       };
49865     } catch (...) {
49866       {
49867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49868       };
49869     }
49870   }
49871 }
49872
49873
49874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
49875   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49876   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
49877
49878   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49879   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
49880   {
49881     try {
49882       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49883     } catch (std::out_of_range& e) {
49884       {
49885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49886       };
49887     } catch (std::exception& e) {
49888       {
49889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49890       };
49891     } catch (...) {
49892       {
49893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49894       };
49895     }
49896   }
49897 }
49898
49899
49900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49901   unsigned int jresult ;
49902   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49903   Dali::Actor arg2 ;
49904   Dali::TouchData *arg3 = 0 ;
49905   Dali::Actor *argp2 ;
49906   bool result;
49907
49908   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49909   argp2 = (Dali::Actor *)jarg2;
49910   if (!argp2) {
49911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49912     return 0;
49913   }
49914   arg2 = *argp2;
49915   arg3 = (Dali::TouchData *)jarg3;
49916   if (!arg3) {
49917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
49918     return 0;
49919   }
49920   {
49921     try {
49922       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
49923     } catch (std::out_of_range& e) {
49924       {
49925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49926       };
49927     } catch (std::exception& e) {
49928       {
49929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49930       };
49931     } catch (...) {
49932       {
49933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49934       };
49935     }
49936   }
49937   jresult = result;
49938   return jresult;
49939 }
49940
49941
49942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
49943   void * jresult ;
49944   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
49945
49946   {
49947     try {
49948       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
49949     } catch (std::out_of_range& e) {
49950       {
49951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49952       };
49953     } catch (std::exception& e) {
49954       {
49955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49956       };
49957     } catch (...) {
49958       {
49959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49960       };
49961     }
49962   }
49963   jresult = (void *)result;
49964   return jresult;
49965 }
49966
49967
49968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
49969   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49970
49971   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49972   {
49973     try {
49974       delete arg1;
49975     } catch (std::out_of_range& e) {
49976       {
49977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49978       };
49979     } catch (std::exception& e) {
49980       {
49981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49982       };
49983     } catch (...) {
49984       {
49985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49986       };
49987     }
49988   }
49989 }
49990
49991
49992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverEventSignal_Empty(void * jarg1) {
49993   unsigned int jresult ;
49994   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
49995   bool result;
49996
49997   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
49998   {
49999     try {
50000       result = (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 *)arg1);
50001     } catch (std::out_of_range& e) {
50002       {
50003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50004       };
50005     } catch (std::exception& e) {
50006       {
50007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50008       };
50009     } catch (...) {
50010       {
50011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50012       };
50013     }
50014   }
50015   jresult = result;
50016   return jresult;
50017 }
50018
50019
50020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverEventSignal_GetConnectionCount(void * jarg1) {
50021   unsigned long jresult ;
50022   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50023   std::size_t result;
50024
50025   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50026   {
50027     try {
50028       result = 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 *)arg1);
50029     } catch (std::out_of_range& e) {
50030       {
50031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50032       };
50033     } catch (std::exception& e) {
50034       {
50035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50036       };
50037     } catch (...) {
50038       {
50039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50040       };
50041     }
50042   }
50043   jresult = (unsigned long)result;
50044   return jresult;
50045 }
50046
50047
50048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverEventSignal_Connect(void * jarg1, void * jarg2) {
50049   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50050   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50051
50052   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50053   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50054   {
50055     try {
50056       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50057     } catch (std::out_of_range& e) {
50058       {
50059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50060       };
50061     } catch (std::exception& e) {
50062       {
50063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50064       };
50065     } catch (...) {
50066       {
50067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50068       };
50069     }
50070   }
50071 }
50072
50073
50074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverEventSignal_Disconnect(void * jarg1, void * jarg2) {
50075   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50076   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50077
50078   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50079   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50080   {
50081     try {
50082       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50083     } catch (std::out_of_range& e) {
50084       {
50085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50086       };
50087     } catch (std::exception& e) {
50088       {
50089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50090       };
50091     } catch (...) {
50092       {
50093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50094       };
50095     }
50096   }
50097 }
50098
50099
50100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverEventSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50101   unsigned int jresult ;
50102   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50103   Dali::Actor arg2 ;
50104   Dali::HoverEvent *arg3 = 0 ;
50105   Dali::Actor *argp2 ;
50106   bool result;
50107
50108   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50109   argp2 = (Dali::Actor *)jarg2;
50110   if (!argp2) {
50111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50112     return 0;
50113   }
50114   arg2 = *argp2;
50115   arg3 = (Dali::HoverEvent *)jarg3;
50116   if (!arg3) {
50117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50118     return 0;
50119   }
50120   {
50121     try {
50122       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50123     } catch (std::out_of_range& e) {
50124       {
50125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50126       };
50127     } catch (std::exception& e) {
50128       {
50129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50130       };
50131     } catch (...) {
50132       {
50133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50134       };
50135     }
50136   }
50137   jresult = result;
50138   return jresult;
50139 }
50140
50141
50142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverEventSignal() {
50143   void * jresult ;
50144   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50145
50146   {
50147     try {
50148       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50149     } catch (std::out_of_range& e) {
50150       {
50151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50152       };
50153     } catch (std::exception& e) {
50154       {
50155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50156       };
50157     } catch (...) {
50158       {
50159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50160       };
50161     }
50162   }
50163   jresult = (void *)result;
50164   return jresult;
50165 }
50166
50167
50168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverEventSignal(void * jarg1) {
50169   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50170
50171   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50172   {
50173     try {
50174       delete arg1;
50175     } catch (std::out_of_range& e) {
50176       {
50177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50178       };
50179     } catch (std::exception& e) {
50180       {
50181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50182       };
50183     } catch (...) {
50184       {
50185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50186       };
50187     }
50188   }
50189 }
50190
50191
50192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelEventSignal_Empty(void * jarg1) {
50193   unsigned int jresult ;
50194   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50195   bool result;
50196
50197   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50198   {
50199     try {
50200       result = (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 *)arg1);
50201     } catch (std::out_of_range& e) {
50202       {
50203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50204       };
50205     } catch (std::exception& e) {
50206       {
50207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50208       };
50209     } catch (...) {
50210       {
50211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50212       };
50213     }
50214   }
50215   jresult = result;
50216   return jresult;
50217 }
50218
50219
50220 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelEventSignal_GetConnectionCount(void * jarg1) {
50221   unsigned long jresult ;
50222   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50223   std::size_t result;
50224
50225   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50226   {
50227     try {
50228       result = 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 *)arg1);
50229     } catch (std::out_of_range& e) {
50230       {
50231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50232       };
50233     } catch (std::exception& e) {
50234       {
50235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50236       };
50237     } catch (...) {
50238       {
50239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50240       };
50241     }
50242   }
50243   jresult = (unsigned long)result;
50244   return jresult;
50245 }
50246
50247
50248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelEventSignal_Connect(void * jarg1, void * jarg2) {
50249   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50250   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50251
50252   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50253   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50254   {
50255     try {
50256       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50257     } catch (std::out_of_range& e) {
50258       {
50259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50260       };
50261     } catch (std::exception& e) {
50262       {
50263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50264       };
50265     } catch (...) {
50266       {
50267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50268       };
50269     }
50270   }
50271 }
50272
50273
50274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelEventSignal_Disconnect(void * jarg1, void * jarg2) {
50275   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50276   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50277
50278   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50279   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50280   {
50281     try {
50282       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50283     } catch (std::out_of_range& e) {
50284       {
50285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50286       };
50287     } catch (std::exception& e) {
50288       {
50289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50290       };
50291     } catch (...) {
50292       {
50293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50294       };
50295     }
50296   }
50297 }
50298
50299
50300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelEventSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50301   unsigned int jresult ;
50302   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50303   Dali::Actor arg2 ;
50304   Dali::WheelEvent *arg3 = 0 ;
50305   Dali::Actor *argp2 ;
50306   bool result;
50307
50308   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50309   argp2 = (Dali::Actor *)jarg2;
50310   if (!argp2) {
50311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50312     return 0;
50313   }
50314   arg2 = *argp2;
50315   arg3 = (Dali::WheelEvent *)jarg3;
50316   if (!arg3) {
50317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50318     return 0;
50319   }
50320   {
50321     try {
50322       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50323     } catch (std::out_of_range& e) {
50324       {
50325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50326       };
50327     } catch (std::exception& e) {
50328       {
50329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50330       };
50331     } catch (...) {
50332       {
50333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50334       };
50335     }
50336   }
50337   jresult = result;
50338   return jresult;
50339 }
50340
50341
50342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelEventSignal() {
50343   void * jresult ;
50344   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50345
50346   {
50347     try {
50348       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50349     } catch (std::out_of_range& e) {
50350       {
50351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50352       };
50353     } catch (std::exception& e) {
50354       {
50355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50356       };
50357     } catch (...) {
50358       {
50359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50360       };
50361     }
50362   }
50363   jresult = (void *)result;
50364   return jresult;
50365 }
50366
50367
50368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelEventSignal(void * jarg1) {
50369   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50370
50371   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50372   {
50373     try {
50374       delete arg1;
50375     } catch (std::out_of_range& e) {
50376       {
50377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50378       };
50379     } catch (std::exception& e) {
50380       {
50381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50382       };
50383     } catch (...) {
50384       {
50385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50386       };
50387     }
50388   }
50389 }
50390
50391
50392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50393   unsigned int jresult ;
50394   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50395   bool result;
50396
50397   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50398   {
50399     try {
50400       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50401     } catch (std::out_of_range& e) {
50402       {
50403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50404       };
50405     } catch (std::exception& e) {
50406       {
50407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50408       };
50409     } catch (...) {
50410       {
50411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50412       };
50413     }
50414   }
50415   jresult = result;
50416   return jresult;
50417 }
50418
50419
50420 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50421   unsigned long jresult ;
50422   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50423   std::size_t result;
50424
50425   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50426   {
50427     try {
50428       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50429     } catch (std::out_of_range& e) {
50430       {
50431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50432       };
50433     } catch (std::exception& e) {
50434       {
50435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50436       };
50437     } catch (...) {
50438       {
50439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50440       };
50441     }
50442   }
50443   jresult = (unsigned long)result;
50444   return jresult;
50445 }
50446
50447
50448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50449   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50450   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50451
50452   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50453   arg2 = (void (*)(Dali::Actor))jarg2;
50454   {
50455     try {
50456       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50457     } catch (std::out_of_range& e) {
50458       {
50459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50460       };
50461     } catch (std::exception& e) {
50462       {
50463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50464       };
50465     } catch (...) {
50466       {
50467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50468       };
50469     }
50470   }
50471 }
50472
50473
50474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50475   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50476   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50477
50478   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50479   arg2 = (void (*)(Dali::Actor))jarg2;
50480   {
50481     try {
50482       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50483     } catch (std::out_of_range& e) {
50484       {
50485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50486       };
50487     } catch (std::exception& e) {
50488       {
50489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50490       };
50491     } catch (...) {
50492       {
50493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50494       };
50495     }
50496   }
50497 }
50498
50499
50500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50501   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50502   Dali::Actor arg2 ;
50503   Dali::Actor *argp2 ;
50504
50505   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50506   argp2 = (Dali::Actor *)jarg2;
50507   if (!argp2) {
50508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50509     return ;
50510   }
50511   arg2 = *argp2;
50512   {
50513     try {
50514       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50515     } catch (std::out_of_range& e) {
50516       {
50517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50518       };
50519     } catch (std::exception& e) {
50520       {
50521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50522       };
50523     } catch (...) {
50524       {
50525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50526       };
50527     }
50528   }
50529 }
50530
50531
50532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50533   void * jresult ;
50534   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50535
50536   {
50537     try {
50538       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50539     } catch (std::out_of_range& e) {
50540       {
50541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50542       };
50543     } catch (std::exception& e) {
50544       {
50545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50546       };
50547     } catch (...) {
50548       {
50549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50550       };
50551     }
50552   }
50553   jresult = (void *)result;
50554   return jresult;
50555 }
50556
50557
50558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50559   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50560
50561   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50562   {
50563     try {
50564       delete arg1;
50565     } catch (std::out_of_range& e) {
50566       {
50567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50568       };
50569     } catch (std::exception& e) {
50570       {
50571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50572       };
50573     } catch (...) {
50574       {
50575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50576       };
50577     }
50578   }
50579 }
50580
50581
50582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50583   unsigned int jresult ;
50584   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50585   bool result;
50586
50587   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50588   {
50589     try {
50590       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50591     } catch (std::out_of_range& e) {
50592       {
50593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50594       };
50595     } catch (std::exception& e) {
50596       {
50597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50598       };
50599     } catch (...) {
50600       {
50601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50602       };
50603     }
50604   }
50605   jresult = result;
50606   return jresult;
50607 }
50608
50609
50610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50611   unsigned long jresult ;
50612   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50613   std::size_t result;
50614
50615   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50616   {
50617     try {
50618       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50619     } catch (std::out_of_range& e) {
50620       {
50621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50622       };
50623     } catch (std::exception& e) {
50624       {
50625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50626       };
50627     } catch (...) {
50628       {
50629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50630       };
50631     }
50632   }
50633   jresult = (unsigned long)result;
50634   return jresult;
50635 }
50636
50637
50638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50639   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50640   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50641
50642   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50643   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50644   {
50645     try {
50646       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50647     } catch (std::out_of_range& e) {
50648       {
50649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50650       };
50651     } catch (std::exception& e) {
50652       {
50653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50654       };
50655     } catch (...) {
50656       {
50657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50658       };
50659     }
50660   }
50661 }
50662
50663
50664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50665   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50666   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50667
50668   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50669   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50670   {
50671     try {
50672       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50673     } catch (std::out_of_range& e) {
50674       {
50675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50676       };
50677     } catch (std::exception& e) {
50678       {
50679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50680       };
50681     } catch (...) {
50682       {
50683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50684       };
50685     }
50686   }
50687 }
50688
50689
50690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
50691   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50692   Dali::KeyEvent *arg2 = 0 ;
50693
50694   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50695   arg2 = (Dali::KeyEvent *)jarg2;
50696   if (!arg2) {
50697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
50698     return ;
50699   }
50700   {
50701     try {
50702       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
50703     } catch (std::out_of_range& e) {
50704       {
50705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50706       };
50707     } catch (std::exception& e) {
50708       {
50709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50710       };
50711     } catch (...) {
50712       {
50713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50714       };
50715     }
50716   }
50717 }
50718
50719
50720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
50721   void * jresult ;
50722   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
50723
50724   {
50725     try {
50726       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
50727     } catch (std::out_of_range& e) {
50728       {
50729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50730       };
50731     } catch (std::exception& e) {
50732       {
50733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50734       };
50735     } catch (...) {
50736       {
50737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50738       };
50739     }
50740   }
50741   jresult = (void *)result;
50742   return jresult;
50743 }
50744
50745
50746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
50747   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50748
50749   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50750   {
50751     try {
50752       delete arg1;
50753     } catch (std::out_of_range& e) {
50754       {
50755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50756       };
50757     } catch (std::exception& e) {
50758       {
50759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50760       };
50761     } catch (...) {
50762       {
50763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50764       };
50765     }
50766   }
50767 }
50768
50769
50770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchEventSignal() {
50771   void * jresult ;
50772   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
50773
50774   {
50775     try {
50776       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
50777     } catch (std::out_of_range& e) {
50778       {
50779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50780       };
50781     } catch (std::exception& e) {
50782       {
50783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50784       };
50785     } catch (...) {
50786       {
50787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50788       };
50789     }
50790   }
50791   jresult = (void *)result;
50792   return jresult;
50793 }
50794
50795
50796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchEventSignal(void * jarg1) {
50797   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
50798
50799   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
50800   {
50801     try {
50802       delete arg1;
50803     } catch (std::out_of_range& e) {
50804       {
50805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50806       };
50807     } catch (std::exception& e) {
50808       {
50809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50810       };
50811     } catch (...) {
50812       {
50813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50814       };
50815     }
50816   }
50817 }
50818
50819
50820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
50821   unsigned int jresult ;
50822   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50823   bool result;
50824
50825   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50826   {
50827     try {
50828       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50829     } catch (std::out_of_range& e) {
50830       {
50831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50832       };
50833     } catch (std::exception& e) {
50834       {
50835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50836       };
50837     } catch (...) {
50838       {
50839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50840       };
50841     }
50842   }
50843   jresult = result;
50844   return jresult;
50845 }
50846
50847
50848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
50849   unsigned long jresult ;
50850   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50851   std::size_t result;
50852
50853   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50854   {
50855     try {
50856       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50857     } catch (std::out_of_range& e) {
50858       {
50859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50860       };
50861     } catch (std::exception& e) {
50862       {
50863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50864       };
50865     } catch (...) {
50866       {
50867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50868       };
50869     }
50870   }
50871   jresult = (unsigned long)result;
50872   return jresult;
50873 }
50874
50875
50876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
50877   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50878   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50879
50880   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50881   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50882   {
50883     try {
50884       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50885     } catch (std::out_of_range& e) {
50886       {
50887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50888       };
50889     } catch (std::exception& e) {
50890       {
50891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50892       };
50893     } catch (...) {
50894       {
50895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50896       };
50897     }
50898   }
50899 }
50900
50901
50902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
50903   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50904   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50905
50906   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50907   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50908   {
50909     try {
50910       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50911     } catch (std::out_of_range& e) {
50912       {
50913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50914       };
50915     } catch (std::exception& e) {
50916       {
50917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50918       };
50919     } catch (...) {
50920       {
50921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50922       };
50923     }
50924   }
50925 }
50926
50927
50928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
50929   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50930   Dali::TouchData *arg2 = 0 ;
50931
50932   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50933   arg2 = (Dali::TouchData *)jarg2;
50934   if (!arg2) {
50935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50936     return ;
50937   }
50938   {
50939     try {
50940       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
50941     } catch (std::out_of_range& e) {
50942       {
50943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50944       };
50945     } catch (std::exception& e) {
50946       {
50947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50948       };
50949     } catch (...) {
50950       {
50951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50952       };
50953     }
50954   }
50955 }
50956
50957
50958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
50959   void * jresult ;
50960   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
50961
50962   {
50963     try {
50964       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
50965     } catch (std::out_of_range& e) {
50966       {
50967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50968       };
50969     } catch (std::exception& e) {
50970       {
50971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50972       };
50973     } catch (...) {
50974       {
50975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50976       };
50977     }
50978   }
50979   jresult = (void *)result;
50980   return jresult;
50981 }
50982
50983
50984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
50985   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50986
50987   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50988   {
50989     try {
50990       delete arg1;
50991     } catch (std::out_of_range& e) {
50992       {
50993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50994       };
50995     } catch (std::exception& e) {
50996       {
50997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50998       };
50999     } catch (...) {
51000       {
51001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51002       };
51003     }
51004   }
51005 }
51006
51007
51008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelEventSignal_Empty(void * jarg1) {
51009   unsigned int jresult ;
51010   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51011   bool result;
51012
51013   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51014   {
51015     try {
51016       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51017     } catch (std::out_of_range& e) {
51018       {
51019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51020       };
51021     } catch (std::exception& e) {
51022       {
51023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51024       };
51025     } catch (...) {
51026       {
51027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51028       };
51029     }
51030   }
51031   jresult = result;
51032   return jresult;
51033 }
51034
51035
51036 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelEventSignal_GetConnectionCount(void * jarg1) {
51037   unsigned long jresult ;
51038   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51039   std::size_t result;
51040
51041   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51042   {
51043     try {
51044       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51045     } catch (std::out_of_range& e) {
51046       {
51047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51048       };
51049     } catch (std::exception& e) {
51050       {
51051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51052       };
51053     } catch (...) {
51054       {
51055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51056       };
51057     }
51058   }
51059   jresult = (unsigned long)result;
51060   return jresult;
51061 }
51062
51063
51064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelEventSignal_Connect(void * jarg1, void * jarg2) {
51065   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51066   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51067
51068   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51069   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51070   {
51071     try {
51072       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51073     } catch (std::out_of_range& e) {
51074       {
51075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51076       };
51077     } catch (std::exception& e) {
51078       {
51079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51080       };
51081     } catch (...) {
51082       {
51083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51084       };
51085     }
51086   }
51087 }
51088
51089
51090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelEventSignal_Disconnect(void * jarg1, void * jarg2) {
51091   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51092   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51093
51094   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51095   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51096   {
51097     try {
51098       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51099     } catch (std::out_of_range& e) {
51100       {
51101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51102       };
51103     } catch (std::exception& e) {
51104       {
51105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51106       };
51107     } catch (...) {
51108       {
51109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51110       };
51111     }
51112   }
51113 }
51114
51115
51116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelEventSignal_Emit(void * jarg1, void * jarg2) {
51117   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51118   Dali::WheelEvent *arg2 = 0 ;
51119
51120   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51121   arg2 = (Dali::WheelEvent *)jarg2;
51122   if (!arg2) {
51123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51124     return ;
51125   }
51126   {
51127     try {
51128       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51129     } catch (std::out_of_range& e) {
51130       {
51131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51132       };
51133     } catch (std::exception& e) {
51134       {
51135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51136       };
51137     } catch (...) {
51138       {
51139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51140       };
51141     }
51142   }
51143 }
51144
51145
51146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelEventSignal() {
51147   void * jresult ;
51148   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51149
51150   {
51151     try {
51152       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51153     } catch (std::out_of_range& e) {
51154       {
51155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51156       };
51157     } catch (std::exception& e) {
51158       {
51159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51160       };
51161     } catch (...) {
51162       {
51163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51164       };
51165     }
51166   }
51167   jresult = (void *)result;
51168   return jresult;
51169 }
51170
51171
51172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelEventSignal(void * jarg1) {
51173   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51174
51175   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51176   {
51177     try {
51178       delete arg1;
51179     } catch (std::out_of_range& e) {
51180       {
51181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51182       };
51183     } catch (std::exception& e) {
51184       {
51185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51186       };
51187     } catch (...) {
51188       {
51189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51190       };
51191     }
51192   }
51193 }
51194
51195
51196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51197   void * jresult ;
51198   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51199
51200   {
51201     try {
51202       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51203     } catch (std::out_of_range& e) {
51204       {
51205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51206       };
51207     } catch (std::exception& e) {
51208       {
51209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51210       };
51211     } catch (...) {
51212       {
51213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51214       };
51215     }
51216   }
51217   jresult = (void *)result;
51218   return jresult;
51219 }
51220
51221
51222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51223   void * jresult ;
51224   Dali::Radian arg1 ;
51225   Dali::Radian arg2 ;
51226   Dali::Radian *argp1 ;
51227   Dali::Radian *argp2 ;
51228   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51229
51230   argp1 = (Dali::Radian *)jarg1;
51231   if (!argp1) {
51232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51233     return 0;
51234   }
51235   arg1 = *argp1;
51236   argp2 = (Dali::Radian *)jarg2;
51237   if (!argp2) {
51238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51239     return 0;
51240   }
51241   arg2 = *argp2;
51242   {
51243     try {
51244       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51245     } catch (std::out_of_range& e) {
51246       {
51247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51248       };
51249     } catch (std::exception& e) {
51250       {
51251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51252       };
51253     } catch (...) {
51254       {
51255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51256       };
51257     }
51258   }
51259   jresult = (void *)result;
51260   return jresult;
51261 }
51262
51263
51264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51265   void * jresult ;
51266   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51267   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51268
51269   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51270   if (!arg1) {
51271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51272     return 0;
51273   }
51274   {
51275     try {
51276       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51277     } catch (std::out_of_range& e) {
51278       {
51279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51280       };
51281     } catch (std::exception& e) {
51282       {
51283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51284       };
51285     } catch (...) {
51286       {
51287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51288       };
51289     }
51290   }
51291   jresult = (void *)result;
51292   return jresult;
51293 }
51294
51295
51296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51297   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51298   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51299
51300   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51301   arg2 = (Dali::Radian *)jarg2;
51302   if (arg1) (arg1)->first = *arg2;
51303 }
51304
51305
51306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51307   void * jresult ;
51308   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51309   Dali::Radian *result = 0 ;
51310
51311   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51312   result = (Dali::Radian *)& ((arg1)->first);
51313   jresult = (void *)result;
51314   return jresult;
51315 }
51316
51317
51318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51319   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51320   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51321
51322   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51323   arg2 = (Dali::Radian *)jarg2;
51324   if (arg1) (arg1)->second = *arg2;
51325 }
51326
51327
51328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51329   void * jresult ;
51330   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51331   Dali::Radian *result = 0 ;
51332
51333   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51334   result = (Dali::Radian *)& ((arg1)->second);
51335   jresult = (void *)result;
51336   return jresult;
51337 }
51338
51339
51340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51341   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51342
51343   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51344   {
51345     try {
51346       delete arg1;
51347     } catch (std::out_of_range& e) {
51348       {
51349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51350       };
51351     } catch (std::exception& e) {
51352       {
51353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51354       };
51355     } catch (...) {
51356       {
51357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51358       };
51359     }
51360   }
51361 }
51362
51363
51364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51365   unsigned int jresult ;
51366   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51367   bool result;
51368
51369   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51370   {
51371     try {
51372       result = (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 *)arg1);
51373     } catch (std::out_of_range& e) {
51374       {
51375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51376       };
51377     } catch (std::exception& e) {
51378       {
51379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51380       };
51381     } catch (...) {
51382       {
51383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51384       };
51385     }
51386   }
51387   jresult = result;
51388   return jresult;
51389 }
51390
51391
51392 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51393   unsigned long jresult ;
51394   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51395   std::size_t result;
51396
51397   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51398   {
51399     try {
51400       result = 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 *)arg1);
51401     } catch (std::out_of_range& e) {
51402       {
51403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51404       };
51405     } catch (std::exception& e) {
51406       {
51407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51408       };
51409     } catch (...) {
51410       {
51411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51412       };
51413     }
51414   }
51415   jresult = (unsigned long)result;
51416   return jresult;
51417 }
51418
51419
51420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51421   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51422   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51423
51424   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51425   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51426   {
51427     try {
51428       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51429     } catch (std::out_of_range& e) {
51430       {
51431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51432       };
51433     } catch (std::exception& e) {
51434       {
51435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51436       };
51437     } catch (...) {
51438       {
51439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51440       };
51441     }
51442   }
51443 }
51444
51445
51446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51447   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51448   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51449
51450   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51451   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51452   {
51453     try {
51454       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51455     } catch (std::out_of_range& e) {
51456       {
51457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51458       };
51459     } catch (std::exception& e) {
51460       {
51461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51462       };
51463     } catch (...) {
51464       {
51465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51466       };
51467     }
51468   }
51469 }
51470
51471
51472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51473   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51474   Dali::Actor arg2 ;
51475   Dali::PanGesture *arg3 = 0 ;
51476   Dali::Actor *argp2 ;
51477
51478   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51479   argp2 = (Dali::Actor *)jarg2;
51480   if (!argp2) {
51481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51482     return ;
51483   }
51484   arg2 = *argp2;
51485   arg3 = (Dali::PanGesture *)jarg3;
51486   if (!arg3) {
51487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51488     return ;
51489   }
51490   {
51491     try {
51492       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51493     } catch (std::out_of_range& e) {
51494       {
51495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51496       };
51497     } catch (std::exception& e) {
51498       {
51499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51500       };
51501     } catch (...) {
51502       {
51503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51504       };
51505     }
51506   }
51507 }
51508
51509
51510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51511   void * jresult ;
51512   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51513
51514   {
51515     try {
51516       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51517     } catch (std::out_of_range& e) {
51518       {
51519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51520       };
51521     } catch (std::exception& e) {
51522       {
51523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51524       };
51525     } catch (...) {
51526       {
51527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51528       };
51529     }
51530   }
51531   jresult = (void *)result;
51532   return jresult;
51533 }
51534
51535
51536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51537   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51538
51539   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51540   {
51541     try {
51542       delete arg1;
51543     } catch (std::out_of_range& e) {
51544       {
51545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51546       };
51547     } catch (std::exception& e) {
51548       {
51549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51550       };
51551     } catch (...) {
51552       {
51553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51554       };
51555     }
51556   }
51557 }
51558
51559
51560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51561   unsigned int jresult ;
51562   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51563   bool result;
51564
51565   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51566   {
51567     try {
51568       result = (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 *)arg1);
51569     } catch (std::out_of_range& e) {
51570       {
51571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51572       };
51573     } catch (std::exception& e) {
51574       {
51575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51576       };
51577     } catch (...) {
51578       {
51579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51580       };
51581     }
51582   }
51583   jresult = result;
51584   return jresult;
51585 }
51586
51587
51588 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51589   unsigned long jresult ;
51590   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51591   std::size_t result;
51592
51593   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51594   {
51595     try {
51596       result = 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 *)arg1);
51597     } catch (std::out_of_range& e) {
51598       {
51599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51600       };
51601     } catch (std::exception& e) {
51602       {
51603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51604       };
51605     } catch (...) {
51606       {
51607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51608       };
51609     }
51610   }
51611   jresult = (unsigned long)result;
51612   return jresult;
51613 }
51614
51615
51616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51617   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51618   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51619
51620   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51621   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51622   {
51623     try {
51624       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51625     } catch (std::out_of_range& e) {
51626       {
51627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51628       };
51629     } catch (std::exception& e) {
51630       {
51631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51632       };
51633     } catch (...) {
51634       {
51635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51636       };
51637     }
51638   }
51639 }
51640
51641
51642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51643   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51644   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51645
51646   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51647   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51648   {
51649     try {
51650       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51651     } catch (std::out_of_range& e) {
51652       {
51653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51654       };
51655     } catch (std::exception& e) {
51656       {
51657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51658       };
51659     } catch (...) {
51660       {
51661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51662       };
51663     }
51664   }
51665 }
51666
51667
51668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51669   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51670   Dali::Actor arg2 ;
51671   Dali::PinchGesture *arg3 = 0 ;
51672   Dali::Actor *argp2 ;
51673
51674   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51675   argp2 = (Dali::Actor *)jarg2;
51676   if (!argp2) {
51677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51678     return ;
51679   }
51680   arg2 = *argp2;
51681   arg3 = (Dali::PinchGesture *)jarg3;
51682   if (!arg3) {
51683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51684     return ;
51685   }
51686   {
51687     try {
51688       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51689     } catch (std::out_of_range& e) {
51690       {
51691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51692       };
51693     } catch (std::exception& e) {
51694       {
51695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51696       };
51697     } catch (...) {
51698       {
51699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51700       };
51701     }
51702   }
51703 }
51704
51705
51706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51707   void * jresult ;
51708   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51709
51710   {
51711     try {
51712       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51713     } catch (std::out_of_range& e) {
51714       {
51715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51716       };
51717     } catch (std::exception& e) {
51718       {
51719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51720       };
51721     } catch (...) {
51722       {
51723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51724       };
51725     }
51726   }
51727   jresult = (void *)result;
51728   return jresult;
51729 }
51730
51731
51732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
51733   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51734
51735   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51736   {
51737     try {
51738       delete arg1;
51739     } catch (std::out_of_range& e) {
51740       {
51741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51742       };
51743     } catch (std::exception& e) {
51744       {
51745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51746       };
51747     } catch (...) {
51748       {
51749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51750       };
51751     }
51752   }
51753 }
51754
51755
51756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
51757   unsigned int jresult ;
51758   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51759   bool result;
51760
51761   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51762   {
51763     try {
51764       result = (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 *)arg1);
51765     } catch (std::out_of_range& e) {
51766       {
51767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51768       };
51769     } catch (std::exception& e) {
51770       {
51771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51772       };
51773     } catch (...) {
51774       {
51775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51776       };
51777     }
51778   }
51779   jresult = result;
51780   return jresult;
51781 }
51782
51783
51784 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51785   unsigned long jresult ;
51786   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51787   std::size_t result;
51788
51789   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51790   {
51791     try {
51792       result = 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 *)arg1);
51793     } catch (std::out_of_range& e) {
51794       {
51795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51796       };
51797     } catch (std::exception& e) {
51798       {
51799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51800       };
51801     } catch (...) {
51802       {
51803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51804       };
51805     }
51806   }
51807   jresult = (unsigned long)result;
51808   return jresult;
51809 }
51810
51811
51812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51813   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51814   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51815
51816   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51817   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51818   {
51819     try {
51820       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51821     } catch (std::out_of_range& e) {
51822       {
51823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51824       };
51825     } catch (std::exception& e) {
51826       {
51827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51828       };
51829     } catch (...) {
51830       {
51831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51832       };
51833     }
51834   }
51835 }
51836
51837
51838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51839   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51840   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51841
51842   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51843   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51844   {
51845     try {
51846       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51847     } catch (std::out_of_range& e) {
51848       {
51849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51850       };
51851     } catch (std::exception& e) {
51852       {
51853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51854       };
51855     } catch (...) {
51856       {
51857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51858       };
51859     }
51860   }
51861 }
51862
51863
51864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51865   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51866   Dali::Actor arg2 ;
51867   Dali::TapGesture *arg3 = 0 ;
51868   Dali::Actor *argp2 ;
51869
51870   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51871   argp2 = (Dali::Actor *)jarg2;
51872   if (!argp2) {
51873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51874     return ;
51875   }
51876   arg2 = *argp2;
51877   arg3 = (Dali::TapGesture *)jarg3;
51878   if (!arg3) {
51879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
51880     return ;
51881   }
51882   {
51883     try {
51884       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
51885     } catch (std::out_of_range& e) {
51886       {
51887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51888       };
51889     } catch (std::exception& e) {
51890       {
51891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51892       };
51893     } catch (...) {
51894       {
51895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51896       };
51897     }
51898   }
51899 }
51900
51901
51902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
51903   void * jresult ;
51904   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
51905
51906   {
51907     try {
51908       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
51909     } catch (std::out_of_range& e) {
51910       {
51911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51912       };
51913     } catch (std::exception& e) {
51914       {
51915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51916       };
51917     } catch (...) {
51918       {
51919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51920       };
51921     }
51922   }
51923   jresult = (void *)result;
51924   return jresult;
51925 }
51926
51927
51928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
51929   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51930
51931   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51932   {
51933     try {
51934       delete arg1;
51935     } catch (std::out_of_range& e) {
51936       {
51937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51938       };
51939     } catch (std::exception& e) {
51940       {
51941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51942       };
51943     } catch (...) {
51944       {
51945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51946       };
51947     }
51948   }
51949 }
51950
51951
51952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
51953   unsigned int jresult ;
51954   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
51955   bool result;
51956
51957   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
51958   {
51959     try {
51960       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
51961     } catch (std::out_of_range& e) {
51962       {
51963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51964       };
51965     } catch (std::exception& e) {
51966       {
51967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51968       };
51969     } catch (...) {
51970       {
51971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51972       };
51973     }
51974   }
51975   jresult = result;
51976   return jresult;
51977 }
51978
51979
51980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
51981   unsigned long jresult ;
51982   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
51983   std::size_t result;
51984
51985   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
51986   {
51987     try {
51988       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
51989     } catch (std::out_of_range& e) {
51990       {
51991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51992       };
51993     } catch (std::exception& e) {
51994       {
51995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51996       };
51997     } catch (...) {
51998       {
51999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52000       };
52001     }
52002   }
52003   jresult = (unsigned long)result;
52004   return jresult;
52005 }
52006
52007
52008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52009   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52010   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52011
52012   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52013   arg2 = (void (*)(Dali::Animation &))jarg2;
52014   {
52015     try {
52016       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52017     } catch (std::out_of_range& e) {
52018       {
52019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52020       };
52021     } catch (std::exception& e) {
52022       {
52023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52024       };
52025     } catch (...) {
52026       {
52027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52028       };
52029     }
52030   }
52031 }
52032
52033
52034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52035   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52036   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52037
52038   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52039   arg2 = (void (*)(Dali::Animation &))jarg2;
52040   {
52041     try {
52042       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52043     } catch (std::out_of_range& e) {
52044       {
52045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52046       };
52047     } catch (std::exception& e) {
52048       {
52049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52050       };
52051     } catch (...) {
52052       {
52053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52054       };
52055     }
52056   }
52057 }
52058
52059
52060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52061   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52062   Dali::Animation *arg2 = 0 ;
52063
52064   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52065   arg2 = (Dali::Animation *)jarg2;
52066   if (!arg2) {
52067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52068     return ;
52069   }
52070   {
52071     try {
52072       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52073     } catch (std::out_of_range& e) {
52074       {
52075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52076       };
52077     } catch (std::exception& e) {
52078       {
52079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52080       };
52081     } catch (...) {
52082       {
52083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52084       };
52085     }
52086   }
52087 }
52088
52089
52090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52091   void * jresult ;
52092   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52093
52094   {
52095     try {
52096       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52097     } catch (std::out_of_range& e) {
52098       {
52099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52100       };
52101     } catch (std::exception& e) {
52102       {
52103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52104       };
52105     } catch (...) {
52106       {
52107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52108       };
52109     }
52110   }
52111   jresult = (void *)result;
52112   return jresult;
52113 }
52114
52115
52116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52117   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52118
52119   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52120   {
52121     try {
52122       delete arg1;
52123     } catch (std::out_of_range& e) {
52124       {
52125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52126       };
52127     } catch (std::exception& e) {
52128       {
52129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52130       };
52131     } catch (...) {
52132       {
52133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52134       };
52135     }
52136   }
52137 }
52138
52139
52140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52141   unsigned int jresult ;
52142   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52143   bool result;
52144
52145   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52146   {
52147     try {
52148       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52149     } catch (std::out_of_range& e) {
52150       {
52151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52152       };
52153     } catch (std::exception& e) {
52154       {
52155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52156       };
52157     } catch (...) {
52158       {
52159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52160       };
52161     }
52162   }
52163   jresult = result;
52164   return jresult;
52165 }
52166
52167
52168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52169   unsigned long jresult ;
52170   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52171   std::size_t result;
52172
52173   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52174   {
52175     try {
52176       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52177     } catch (std::out_of_range& e) {
52178       {
52179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52180       };
52181     } catch (std::exception& e) {
52182       {
52183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52184       };
52185     } catch (...) {
52186       {
52187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52188       };
52189     }
52190   }
52191   jresult = (unsigned long)result;
52192   return jresult;
52193 }
52194
52195
52196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52197   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52198   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52199
52200   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52201   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52202   {
52203     try {
52204       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52205     } catch (std::out_of_range& e) {
52206       {
52207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52208       };
52209     } catch (std::exception& e) {
52210       {
52211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52212       };
52213     } catch (...) {
52214       {
52215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52216       };
52217     }
52218   }
52219 }
52220
52221
52222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52223   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52224   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52225
52226   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52227   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52228   {
52229     try {
52230       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52231     } catch (std::out_of_range& e) {
52232       {
52233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52234       };
52235     } catch (std::exception& e) {
52236       {
52237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52238       };
52239     } catch (...) {
52240       {
52241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52242       };
52243     }
52244   }
52245 }
52246
52247
52248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52249   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52250   Dali::ResourceImage arg2 ;
52251   Dali::ResourceImage *argp2 ;
52252
52253   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52254   argp2 = (Dali::ResourceImage *)jarg2;
52255   if (!argp2) {
52256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52257     return ;
52258   }
52259   arg2 = *argp2;
52260   {
52261     try {
52262       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52263     } catch (std::out_of_range& e) {
52264       {
52265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52266       };
52267     } catch (std::exception& e) {
52268       {
52269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52270       };
52271     } catch (...) {
52272       {
52273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52274       };
52275     }
52276   }
52277 }
52278
52279
52280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52281   void * jresult ;
52282   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52283
52284   {
52285     try {
52286       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52287     } catch (std::out_of_range& e) {
52288       {
52289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52290       };
52291     } catch (std::exception& e) {
52292       {
52293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52294       };
52295     } catch (...) {
52296       {
52297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52298       };
52299     }
52300   }
52301   jresult = (void *)result;
52302   return jresult;
52303 }
52304
52305
52306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52307   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52308
52309   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52310   {
52311     try {
52312       delete arg1;
52313     } catch (std::out_of_range& e) {
52314       {
52315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52316       };
52317     } catch (std::exception& e) {
52318       {
52319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52320       };
52321     } catch (...) {
52322       {
52323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52324       };
52325     }
52326   }
52327 }
52328
52329
52330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52331   void * jresult ;
52332   Dali::Timer *result = 0 ;
52333
52334   {
52335     try {
52336       result = (Dali::Timer *)new Dali::Timer();
52337     } catch (std::out_of_range& e) {
52338       {
52339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52340       };
52341     } catch (std::exception& e) {
52342       {
52343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52344       };
52345     } catch (...) {
52346       {
52347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52348       };
52349     }
52350   }
52351   jresult = (void *)result;
52352   return jresult;
52353 }
52354
52355
52356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52357   void * jresult ;
52358   unsigned int arg1 ;
52359   Dali::Timer result;
52360
52361   arg1 = (unsigned int)jarg1;
52362   {
52363     try {
52364       result = Dali::Timer::New(arg1);
52365     } catch (std::out_of_range& e) {
52366       {
52367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52368       };
52369     } catch (std::exception& e) {
52370       {
52371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52372       };
52373     } catch (...) {
52374       {
52375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52376       };
52377     }
52378   }
52379   jresult = new Dali::Timer((const Dali::Timer &)result);
52380   return jresult;
52381 }
52382
52383
52384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52385   void * jresult ;
52386   Dali::Timer *arg1 = 0 ;
52387   Dali::Timer *result = 0 ;
52388
52389   arg1 = (Dali::Timer *)jarg1;
52390   if (!arg1) {
52391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52392     return 0;
52393   }
52394   {
52395     try {
52396       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52397     } catch (std::out_of_range& e) {
52398       {
52399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52400       };
52401     } catch (std::exception& e) {
52402       {
52403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52404       };
52405     } catch (...) {
52406       {
52407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52408       };
52409     }
52410   }
52411   jresult = (void *)result;
52412   return jresult;
52413 }
52414
52415
52416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52417   void * jresult ;
52418   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52419   Dali::Timer *arg2 = 0 ;
52420   Dali::Timer *result = 0 ;
52421
52422   arg1 = (Dali::Timer *)jarg1;
52423   arg2 = (Dali::Timer *)jarg2;
52424   if (!arg2) {
52425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52426     return 0;
52427   }
52428   {
52429     try {
52430       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52431     } catch (std::out_of_range& e) {
52432       {
52433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52434       };
52435     } catch (std::exception& e) {
52436       {
52437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52438       };
52439     } catch (...) {
52440       {
52441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52442       };
52443     }
52444   }
52445   jresult = (void *)result;
52446   return jresult;
52447 }
52448
52449
52450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52451   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52452
52453   arg1 = (Dali::Timer *)jarg1;
52454   {
52455     try {
52456       delete arg1;
52457     } catch (std::out_of_range& e) {
52458       {
52459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52460       };
52461     } catch (std::exception& e) {
52462       {
52463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52464       };
52465     } catch (...) {
52466       {
52467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52468       };
52469     }
52470   }
52471 }
52472
52473
52474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52475   void * jresult ;
52476   Dali::BaseHandle arg1 ;
52477   Dali::BaseHandle *argp1 ;
52478   Dali::Timer result;
52479
52480   argp1 = (Dali::BaseHandle *)jarg1;
52481   if (!argp1) {
52482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52483     return 0;
52484   }
52485   arg1 = *argp1;
52486   {
52487     try {
52488       result = Dali::Timer::DownCast(arg1);
52489     } catch (std::out_of_range& e) {
52490       {
52491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52492       };
52493     } catch (std::exception& e) {
52494       {
52495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52496       };
52497     } catch (...) {
52498       {
52499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52500       };
52501     }
52502   }
52503   jresult = new Dali::Timer((const Dali::Timer &)result);
52504   return jresult;
52505 }
52506
52507
52508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52509   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52510
52511   arg1 = (Dali::Timer *)jarg1;
52512   {
52513     try {
52514       (arg1)->Start();
52515     } catch (std::out_of_range& e) {
52516       {
52517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52518       };
52519     } catch (std::exception& e) {
52520       {
52521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52522       };
52523     } catch (...) {
52524       {
52525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52526       };
52527     }
52528   }
52529 }
52530
52531
52532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52533   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52534
52535   arg1 = (Dali::Timer *)jarg1;
52536   {
52537     try {
52538       (arg1)->Stop();
52539     } catch (std::out_of_range& e) {
52540       {
52541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52542       };
52543     } catch (std::exception& e) {
52544       {
52545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52546       };
52547     } catch (...) {
52548       {
52549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52550       };
52551     }
52552   }
52553 }
52554
52555
52556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52557   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52558   unsigned int arg2 ;
52559
52560   arg1 = (Dali::Timer *)jarg1;
52561   arg2 = (unsigned int)jarg2;
52562   {
52563     try {
52564       (arg1)->SetInterval(arg2);
52565     } catch (std::out_of_range& e) {
52566       {
52567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52568       };
52569     } catch (std::exception& e) {
52570       {
52571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52572       };
52573     } catch (...) {
52574       {
52575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52576       };
52577     }
52578   }
52579 }
52580
52581
52582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52583   unsigned int jresult ;
52584   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52585   unsigned int result;
52586
52587   arg1 = (Dali::Timer *)jarg1;
52588   {
52589     try {
52590       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52591     } catch (std::out_of_range& e) {
52592       {
52593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52594       };
52595     } catch (std::exception& e) {
52596       {
52597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52598       };
52599     } catch (...) {
52600       {
52601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52602       };
52603     }
52604   }
52605   jresult = result;
52606   return jresult;
52607 }
52608
52609
52610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52611   unsigned int jresult ;
52612   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52613   bool result;
52614
52615   arg1 = (Dali::Timer *)jarg1;
52616   {
52617     try {
52618       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52619     } catch (std::out_of_range& e) {
52620       {
52621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52622       };
52623     } catch (std::exception& e) {
52624       {
52625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52626       };
52627     } catch (...) {
52628       {
52629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52630       };
52631     }
52632   }
52633   jresult = result;
52634   return jresult;
52635 }
52636
52637
52638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52639   void * jresult ;
52640   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52641   Dali::Timer::TimerSignalType *result = 0 ;
52642
52643   arg1 = (Dali::Timer *)jarg1;
52644   {
52645     try {
52646       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52647     } catch (std::out_of_range& e) {
52648       {
52649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52650       };
52651     } catch (std::exception& e) {
52652       {
52653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52654       };
52655     } catch (...) {
52656       {
52657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52658       };
52659     }
52660   }
52661   jresult = (void *)result;
52662   return jresult;
52663 }
52664
52665
52666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
52667   void * jresult ;
52668   Dali::DragAndDropDetector *result = 0 ;
52669
52670   {
52671     try {
52672       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
52673     } catch (std::out_of_range& e) {
52674       {
52675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52676       };
52677     } catch (std::exception& e) {
52678       {
52679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52680       };
52681     } catch (...) {
52682       {
52683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52684       };
52685     }
52686   }
52687   jresult = (void *)result;
52688   return jresult;
52689 }
52690
52691
52692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
52693   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52694
52695   arg1 = (Dali::DragAndDropDetector *)jarg1;
52696   {
52697     try {
52698       delete arg1;
52699     } catch (std::out_of_range& e) {
52700       {
52701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52702       };
52703     } catch (std::exception& e) {
52704       {
52705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52706       };
52707     } catch (...) {
52708       {
52709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52710       };
52711     }
52712   }
52713 }
52714
52715
52716 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
52717   char * jresult ;
52718   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52719   std::string *result = 0 ;
52720
52721   arg1 = (Dali::DragAndDropDetector *)jarg1;
52722   {
52723     try {
52724       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
52725     } catch (std::out_of_range& e) {
52726       {
52727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52728       };
52729     } catch (std::exception& e) {
52730       {
52731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52732       };
52733     } catch (...) {
52734       {
52735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52736       };
52737     }
52738   }
52739   jresult = SWIG_csharp_string_callback(result->c_str());
52740   return jresult;
52741 }
52742
52743
52744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
52745   void * jresult ;
52746   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52747   Dali::Vector2 result;
52748
52749   arg1 = (Dali::DragAndDropDetector *)jarg1;
52750   {
52751     try {
52752       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
52753     } catch (std::out_of_range& e) {
52754       {
52755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52756       };
52757     } catch (std::exception& e) {
52758       {
52759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52760       };
52761     } catch (...) {
52762       {
52763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52764       };
52765     }
52766   }
52767   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
52768   return jresult;
52769 }
52770
52771
52772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
52773   void * jresult ;
52774   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52775   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52776
52777   arg1 = (Dali::DragAndDropDetector *)jarg1;
52778   {
52779     try {
52780       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
52781     } catch (std::out_of_range& e) {
52782       {
52783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52784       };
52785     } catch (std::exception& e) {
52786       {
52787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52788       };
52789     } catch (...) {
52790       {
52791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52792       };
52793     }
52794   }
52795   jresult = (void *)result;
52796   return jresult;
52797 }
52798
52799
52800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
52801   void * jresult ;
52802   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52803   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52804
52805   arg1 = (Dali::DragAndDropDetector *)jarg1;
52806   {
52807     try {
52808       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
52809     } catch (std::out_of_range& e) {
52810       {
52811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52812       };
52813     } catch (std::exception& e) {
52814       {
52815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52816       };
52817     } catch (...) {
52818       {
52819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52820       };
52821     }
52822   }
52823   jresult = (void *)result;
52824   return jresult;
52825 }
52826
52827
52828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
52829   void * jresult ;
52830   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52831   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52832
52833   arg1 = (Dali::DragAndDropDetector *)jarg1;
52834   {
52835     try {
52836       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
52837     } catch (std::out_of_range& e) {
52838       {
52839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52840       };
52841     } catch (std::exception& e) {
52842       {
52843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52844       };
52845     } catch (...) {
52846       {
52847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52848       };
52849     }
52850   }
52851   jresult = (void *)result;
52852   return jresult;
52853 }
52854
52855
52856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
52857   void * jresult ;
52858   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52859   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52860
52861   arg1 = (Dali::DragAndDropDetector *)jarg1;
52862   {
52863     try {
52864       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
52865     } catch (std::out_of_range& e) {
52866       {
52867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52868       };
52869     } catch (std::exception& e) {
52870       {
52871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52872       };
52873     } catch (...) {
52874       {
52875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52876       };
52877     }
52878   }
52879   jresult = (void *)result;
52880   return jresult;
52881 }
52882
52883
52884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
52885   void * jresult ;
52886   Dali::PositionSize arg1 ;
52887   std::string *arg2 = 0 ;
52888   bool arg3 ;
52889   Dali::PositionSize *argp1 ;
52890   Dali::Window result;
52891
52892   argp1 = (Dali::PositionSize *)jarg1;
52893   if (!argp1) {
52894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
52895     return 0;
52896   }
52897   arg1 = *argp1;
52898   if (!jarg2) {
52899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52900     return 0;
52901   }
52902   std::string arg2_str(jarg2);
52903   arg2 = &arg2_str;
52904   arg3 = jarg3 ? true : false;
52905   {
52906     try {
52907       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
52908     } catch (std::out_of_range& e) {
52909       {
52910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52911       };
52912     } catch (std::exception& e) {
52913       {
52914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52915       };
52916     } catch (...) {
52917       {
52918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52919       };
52920     }
52921   }
52922   jresult = new Dali::Window((const Dali::Window &)result);
52923
52924   //argout typemap for const std::string&
52925
52926   return jresult;
52927 }
52928
52929
52930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
52931   void * jresult ;
52932   Dali::PositionSize arg1 ;
52933   std::string *arg2 = 0 ;
52934   Dali::PositionSize *argp1 ;
52935   Dali::Window result;
52936
52937   argp1 = (Dali::PositionSize *)jarg1;
52938   if (!argp1) {
52939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
52940     return 0;
52941   }
52942   arg1 = *argp1;
52943   if (!jarg2) {
52944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52945     return 0;
52946   }
52947   std::string arg2_str(jarg2);
52948   arg2 = &arg2_str;
52949   {
52950     try {
52951       result = Dali::Window::New(arg1,(std::string const &)*arg2);
52952     } catch (std::out_of_range& e) {
52953       {
52954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52955       };
52956     } catch (std::exception& e) {
52957       {
52958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52959       };
52960     } catch (...) {
52961       {
52962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52963       };
52964     }
52965   }
52966   jresult = new Dali::Window((const Dali::Window &)result);
52967
52968   //argout typemap for const std::string&
52969
52970   return jresult;
52971 }
52972
52973
52974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
52975   void * jresult ;
52976   Dali::PositionSize arg1 ;
52977   std::string *arg2 = 0 ;
52978   std::string *arg3 = 0 ;
52979   bool arg4 ;
52980   Dali::PositionSize *argp1 ;
52981   Dali::Window result;
52982
52983   argp1 = (Dali::PositionSize *)jarg1;
52984   if (!argp1) {
52985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
52986     return 0;
52987   }
52988   arg1 = *argp1;
52989   if (!jarg2) {
52990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52991     return 0;
52992   }
52993   std::string arg2_str(jarg2);
52994   arg2 = &arg2_str;
52995   if (!jarg3) {
52996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
52997     return 0;
52998   }
52999   std::string arg3_str(jarg3);
53000   arg3 = &arg3_str;
53001   arg4 = jarg4 ? true : false;
53002   {
53003     try {
53004       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53005     } catch (std::out_of_range& e) {
53006       {
53007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53008       };
53009     } catch (std::exception& e) {
53010       {
53011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53012       };
53013     } catch (...) {
53014       {
53015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53016       };
53017     }
53018   }
53019   jresult = new Dali::Window((const Dali::Window &)result);
53020
53021   //argout typemap for const std::string&
53022
53023
53024   //argout typemap for const std::string&
53025
53026   return jresult;
53027 }
53028
53029
53030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53031   void * jresult ;
53032   Dali::PositionSize arg1 ;
53033   std::string *arg2 = 0 ;
53034   std::string *arg3 = 0 ;
53035   Dali::PositionSize *argp1 ;
53036   Dali::Window result;
53037
53038   argp1 = (Dali::PositionSize *)jarg1;
53039   if (!argp1) {
53040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53041     return 0;
53042   }
53043   arg1 = *argp1;
53044   if (!jarg2) {
53045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53046     return 0;
53047   }
53048   std::string arg2_str(jarg2);
53049   arg2 = &arg2_str;
53050   if (!jarg3) {
53051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53052     return 0;
53053   }
53054   std::string arg3_str(jarg3);
53055   arg3 = &arg3_str;
53056   {
53057     try {
53058       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53059     } catch (std::out_of_range& e) {
53060       {
53061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53062       };
53063     } catch (std::exception& e) {
53064       {
53065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53066       };
53067     } catch (...) {
53068       {
53069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53070       };
53071     }
53072   }
53073   jresult = new Dali::Window((const Dali::Window &)result);
53074
53075   //argout typemap for const std::string&
53076
53077
53078   //argout typemap for const std::string&
53079
53080   return jresult;
53081 }
53082
53083
53084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53085   void * jresult ;
53086   Dali::Window *result = 0 ;
53087
53088   {
53089     try {
53090       result = (Dali::Window *)new Dali::Window();
53091     } catch (std::out_of_range& e) {
53092       {
53093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53094       };
53095     } catch (std::exception& e) {
53096       {
53097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53098       };
53099     } catch (...) {
53100       {
53101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53102       };
53103     }
53104   }
53105   jresult = (void *)result;
53106   return jresult;
53107 }
53108
53109
53110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53111   Dali::Window *arg1 = (Dali::Window *) 0 ;
53112
53113   arg1 = (Dali::Window *)jarg1;
53114   {
53115     try {
53116       delete arg1;
53117     } catch (std::out_of_range& e) {
53118       {
53119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53120       };
53121     } catch (std::exception& e) {
53122       {
53123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53124       };
53125     } catch (...) {
53126       {
53127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53128       };
53129     }
53130   }
53131 }
53132
53133
53134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53135   void * jresult ;
53136   Dali::Window *arg1 = 0 ;
53137   Dali::Window *result = 0 ;
53138
53139   arg1 = (Dali::Window *)jarg1;
53140   if (!arg1) {
53141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53142     return 0;
53143   }
53144   {
53145     try {
53146       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53147     } catch (std::out_of_range& e) {
53148       {
53149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53150       };
53151     } catch (std::exception& e) {
53152       {
53153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53154       };
53155     } catch (...) {
53156       {
53157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53158       };
53159     }
53160   }
53161   jresult = (void *)result;
53162   return jresult;
53163 }
53164
53165
53166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53167   void * jresult ;
53168   Dali::Window *arg1 = (Dali::Window *) 0 ;
53169   Dali::Window *arg2 = 0 ;
53170   Dali::Window *result = 0 ;
53171
53172   arg1 = (Dali::Window *)jarg1;
53173   arg2 = (Dali::Window *)jarg2;
53174   if (!arg2) {
53175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53176     return 0;
53177   }
53178   {
53179     try {
53180       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53181     } catch (std::out_of_range& e) {
53182       {
53183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53184       };
53185     } catch (std::exception& e) {
53186       {
53187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53188       };
53189     } catch (...) {
53190       {
53191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53192       };
53193     }
53194   }
53195   jresult = (void *)result;
53196   return jresult;
53197 }
53198
53199
53200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53201   Dali::Window *arg1 = (Dali::Window *) 0 ;
53202   Dali::Window::IndicatorVisibleMode arg2 ;
53203
53204   arg1 = (Dali::Window *)jarg1;
53205   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53206   {
53207     try {
53208       (arg1)->ShowIndicator(arg2);
53209     } catch (std::out_of_range& e) {
53210       {
53211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53212       };
53213     } catch (std::exception& e) {
53214       {
53215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53216       };
53217     } catch (...) {
53218       {
53219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53220       };
53221     }
53222   }
53223 }
53224
53225
53226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53227   Dali::Window *arg1 = (Dali::Window *) 0 ;
53228   Dali::Window::IndicatorBgOpacity arg2 ;
53229
53230   arg1 = (Dali::Window *)jarg1;
53231   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53232   {
53233     try {
53234       (arg1)->SetIndicatorBgOpacity(arg2);
53235     } catch (std::out_of_range& e) {
53236       {
53237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53238       };
53239     } catch (std::exception& e) {
53240       {
53241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53242       };
53243     } catch (...) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53246       };
53247     }
53248   }
53249 }
53250
53251
53252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53253   Dali::Window *arg1 = (Dali::Window *) 0 ;
53254   Dali::Window::WindowOrientation arg2 ;
53255
53256   arg1 = (Dali::Window *)jarg1;
53257   arg2 = (Dali::Window::WindowOrientation)jarg2;
53258   {
53259     try {
53260       (arg1)->RotateIndicator(arg2);
53261     } catch (std::out_of_range& e) {
53262       {
53263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53264       };
53265     } catch (std::exception& e) {
53266       {
53267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53268       };
53269     } catch (...) {
53270       {
53271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53272       };
53273     }
53274   }
53275 }
53276
53277
53278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53279   Dali::Window *arg1 = (Dali::Window *) 0 ;
53280   std::string arg2 ;
53281   std::string arg3 ;
53282
53283   arg1 = (Dali::Window *)jarg1;
53284   if (!jarg2) {
53285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53286     return ;
53287   }
53288   (&arg2)->assign(jarg2);
53289   if (!jarg3) {
53290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53291     return ;
53292   }
53293   (&arg3)->assign(jarg3);
53294   {
53295     try {
53296       (arg1)->SetClass(arg2,arg3);
53297     } catch (std::out_of_range& e) {
53298       {
53299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53300       };
53301     } catch (std::exception& e) {
53302       {
53303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53304       };
53305     } catch (...) {
53306       {
53307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53308       };
53309     }
53310   }
53311 }
53312
53313
53314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53315   Dali::Window *arg1 = (Dali::Window *) 0 ;
53316
53317   arg1 = (Dali::Window *)jarg1;
53318   {
53319     try {
53320       (arg1)->Raise();
53321     } catch (std::out_of_range& e) {
53322       {
53323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53324       };
53325     } catch (std::exception& e) {
53326       {
53327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53328       };
53329     } catch (...) {
53330       {
53331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53332       };
53333     }
53334   }
53335 }
53336
53337
53338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
53339   Dali::Window *arg1 = (Dali::Window *) 0 ;
53340
53341   arg1 = (Dali::Window *)jarg1;
53342   {
53343     try {
53344       (arg1)->Lower();
53345     } catch (std::out_of_range& e) {
53346       {
53347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53348       };
53349     } catch (std::exception& e) {
53350       {
53351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53352       };
53353     } catch (...) {
53354       {
53355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53356       };
53357     }
53358   }
53359 }
53360
53361
53362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53363   Dali::Window *arg1 = (Dali::Window *) 0 ;
53364
53365   arg1 = (Dali::Window *)jarg1;
53366   {
53367     try {
53368       (arg1)->Activate();
53369     } catch (std::out_of_range& e) {
53370       {
53371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53372       };
53373     } catch (std::exception& e) {
53374       {
53375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53376       };
53377     } catch (...) {
53378       {
53379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53380       };
53381     }
53382   }
53383 }
53384
53385
53386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53387   Dali::Window *arg1 = (Dali::Window *) 0 ;
53388   Dali::Window::WindowOrientation arg2 ;
53389
53390   arg1 = (Dali::Window *)jarg1;
53391   arg2 = (Dali::Window::WindowOrientation)jarg2;
53392   {
53393     try {
53394       (arg1)->AddAvailableOrientation(arg2);
53395     } catch (std::out_of_range& e) {
53396       {
53397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53398       };
53399     } catch (std::exception& e) {
53400       {
53401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53402       };
53403     } catch (...) {
53404       {
53405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53406       };
53407     }
53408   }
53409 }
53410
53411
53412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53413   Dali::Window *arg1 = (Dali::Window *) 0 ;
53414   Dali::Window::WindowOrientation arg2 ;
53415
53416   arg1 = (Dali::Window *)jarg1;
53417   arg2 = (Dali::Window::WindowOrientation)jarg2;
53418   {
53419     try {
53420       (arg1)->RemoveAvailableOrientation(arg2);
53421     } catch (std::out_of_range& e) {
53422       {
53423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53424       };
53425     } catch (std::exception& e) {
53426       {
53427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53428       };
53429     } catch (...) {
53430       {
53431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53432       };
53433     }
53434   }
53435 }
53436
53437
53438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53439   Dali::Window *arg1 = (Dali::Window *) 0 ;
53440   Dali::Window::WindowOrientation arg2 ;
53441
53442   arg1 = (Dali::Window *)jarg1;
53443   arg2 = (Dali::Window::WindowOrientation)jarg2;
53444   {
53445     try {
53446       (arg1)->SetPreferredOrientation(arg2);
53447     } catch (std::out_of_range& e) {
53448       {
53449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53450       };
53451     } catch (std::exception& e) {
53452       {
53453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53454       };
53455     } catch (...) {
53456       {
53457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53458       };
53459     }
53460   }
53461 }
53462
53463
53464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53465   int jresult ;
53466   Dali::Window *arg1 = (Dali::Window *) 0 ;
53467   Dali::Window::WindowOrientation result;
53468
53469   arg1 = (Dali::Window *)jarg1;
53470   {
53471     try {
53472       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
53473     } catch (std::out_of_range& e) {
53474       {
53475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53476       };
53477     } catch (std::exception& e) {
53478       {
53479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53480       };
53481     } catch (...) {
53482       {
53483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53484       };
53485     }
53486   }
53487   jresult = (int)result;
53488   return jresult;
53489 }
53490
53491
53492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
53493   void * jresult ;
53494   Dali::Window *arg1 = (Dali::Window *) 0 ;
53495   Dali::DragAndDropDetector result;
53496
53497   arg1 = (Dali::Window *)jarg1;
53498   {
53499     try {
53500       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
53501     } catch (std::out_of_range& e) {
53502       {
53503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53504       };
53505     } catch (std::exception& e) {
53506       {
53507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53508       };
53509     } catch (...) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53512       };
53513     }
53514   }
53515   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
53516   return jresult;
53517 }
53518
53519
53520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
53521   void * jresult ;
53522   Dali::Window *arg1 = (Dali::Window *) 0 ;
53523   Dali::Any result;
53524
53525   arg1 = (Dali::Window *)jarg1;
53526   {
53527     try {
53528       result = ((Dali::Window const *)arg1)->GetNativeHandle();
53529     } catch (std::out_of_range& e) {
53530       {
53531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53532       };
53533     } catch (std::exception& e) {
53534       {
53535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53536       };
53537     } catch (...) {
53538       {
53539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53540       };
53541     }
53542   }
53543   jresult = new Dali::Any((const Dali::Any &)result);
53544   return jresult;
53545 }
53546
53547
53548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_IndicatorVisibilityChangedSignal(void * jarg1) {
53549   void * jresult ;
53550   Dali::Window *arg1 = (Dali::Window *) 0 ;
53551   Dali::Window::IndicatorSignalType *result = 0 ;
53552
53553   arg1 = (Dali::Window *)jarg1;
53554   {
53555     try {
53556       result = (Dali::Window::IndicatorSignalType *) &(arg1)->IndicatorVisibilityChangedSignal();
53557     } catch (std::out_of_range& e) {
53558       {
53559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53560       };
53561     } catch (std::exception& e) {
53562       {
53563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53564       };
53565     } catch (...) {
53566       {
53567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53568       };
53569     }
53570   }
53571   jresult = (void *)result;
53572   return jresult;
53573 }
53574
53575
53576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
53577   void * jresult ;
53578   Dali::Application result;
53579
53580   {
53581     try {
53582       result = Dali::Application::New();
53583     } catch (std::out_of_range& e) {
53584       {
53585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53586       };
53587     } catch (std::exception& e) {
53588       {
53589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53590       };
53591     } catch (...) {
53592       {
53593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53594       };
53595     }
53596   }
53597   jresult = new Dali::Application((const Dali::Application &)result);
53598   return jresult;
53599 }
53600
53601
53602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
53603   void * jresult ;
53604   int *arg1 = (int *) 0 ;
53605   char ***arg2 ;
53606   Dali::Application result;
53607
53608   {
53609     // Todo generate argv data from the C# args
53610     char **array;         // two dimensional array
53611     int numStrings = 1;     // number of strings
53612     int stringLength = 30;      // max string length.
53613     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
53614     argV = array;
53615
53616     // allocate the string data
53617     for( int i=0; i < numStrings; i++)
53618     {
53619       array[i]=(char *)malloc( stringLength * sizeof(char *) );
53620     }
53621     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
53622
53623     strcpy( array[0], "dali-csharp-app");
53624
53625     arg1 = &argC;
53626     arg2 = &argV;
53627   }
53628   {
53629     try {
53630       result = Dali::Application::New(arg1,arg2);
53631     } catch (std::out_of_range& e) {
53632       {
53633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53634       };
53635     } catch (std::exception& e) {
53636       {
53637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53638       };
53639     } catch (...) {
53640       {
53641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53642       };
53643     }
53644   }
53645   jresult = new Dali::Application((const Dali::Application &)result);
53646   return jresult;
53647 }
53648
53649
53650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
53651   void * jresult ;
53652   int *arg1 = (int *) 0 ;
53653   char ***arg2 ;
53654   std::string *arg3 = 0 ;
53655   Dali::Application result;
53656
53657   {
53658     // Todo generate argv data from the C# args
53659     char **array;         // two dimensional array
53660     int numStrings = 1;     // number of strings
53661     int stringLength = 30;      // max string length.
53662     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
53663     argV = array;
53664
53665     // allocate the string data
53666     for( int i=0; i < numStrings; i++)
53667     {
53668       array[i]=(char *)malloc( stringLength * sizeof(char *) );
53669     }
53670     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
53671
53672     strcpy( array[0], "dali-csharp-app");
53673
53674     arg1 = &argC;
53675     arg2 = &argV;
53676   }
53677   if (!jarg3) {
53678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53679     return 0;
53680   }
53681   std::string arg3_str(jarg3);
53682   arg3 = &arg3_str;
53683   {
53684     try {
53685       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
53686     } catch (std::out_of_range& e) {
53687       {
53688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53689       };
53690     } catch (std::exception& e) {
53691       {
53692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53693       };
53694     } catch (...) {
53695       {
53696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53697       };
53698     }
53699   }
53700   jresult = new Dali::Application((const Dali::Application &)result);
53701
53702   //argout typemap for const std::string&
53703
53704   return jresult;
53705 }
53706
53707
53708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
53709   void * jresult ;
53710   int *arg1 = (int *) 0 ;
53711   char ***arg2 ;
53712   std::string *arg3 = 0 ;
53713   Dali::Application::WINDOW_MODE arg4 ;
53714   Dali::Application result;
53715
53716   {
53717     // Todo generate argv data from the C# args
53718     char **array;         // two dimensional array
53719     int numStrings = 1;     // number of strings
53720     int stringLength = 30;      // max string length.
53721     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
53722     argV = array;
53723
53724     // allocate the string data
53725     for( int i=0; i < numStrings; i++)
53726     {
53727       array[i]=(char *)malloc( stringLength * sizeof(char *) );
53728     }
53729     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
53730
53731     strcpy( array[0], "dali-csharp-app");
53732
53733     arg1 = &argC;
53734     arg2 = &argV;
53735   }
53736   if (!jarg3) {
53737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53738     return 0;
53739   }
53740   std::string arg3_str(jarg3);
53741   arg3 = &arg3_str;
53742   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
53743   {
53744     try {
53745       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
53746     } catch (std::out_of_range& e) {
53747       {
53748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53749       };
53750     } catch (std::exception& e) {
53751       {
53752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53753       };
53754     } catch (...) {
53755       {
53756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53757       };
53758     }
53759   }
53760   jresult = new Dali::Application((const Dali::Application &)result);
53761
53762   //argout typemap for const std::string&
53763
53764   return jresult;
53765 }
53766
53767
53768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
53769   void * jresult ;
53770   Dali::Application *result = 0 ;
53771
53772   {
53773     try {
53774       result = (Dali::Application *)new Dali::Application();
53775     } catch (std::out_of_range& e) {
53776       {
53777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53778       };
53779     } catch (std::exception& e) {
53780       {
53781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53786       };
53787     }
53788   }
53789   jresult = (void *)result;
53790   return jresult;
53791 }
53792
53793
53794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
53795   void * jresult ;
53796   Dali::Application *arg1 = 0 ;
53797   Dali::Application *result = 0 ;
53798
53799   arg1 = (Dali::Application *)jarg1;
53800   if (!arg1) {
53801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
53802     return 0;
53803   }
53804   {
53805     try {
53806       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
53807     } catch (std::out_of_range& e) {
53808       {
53809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53810       };
53811     } catch (std::exception& e) {
53812       {
53813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53814       };
53815     } catch (...) {
53816       {
53817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53818       };
53819     }
53820   }
53821   jresult = (void *)result;
53822   return jresult;
53823 }
53824
53825
53826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
53827   void * jresult ;
53828   Dali::Application *arg1 = (Dali::Application *) 0 ;
53829   Dali::Application *arg2 = 0 ;
53830   Dali::Application *result = 0 ;
53831
53832   arg1 = (Dali::Application *)jarg1;
53833   arg2 = (Dali::Application *)jarg2;
53834   if (!arg2) {
53835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
53836     return 0;
53837   }
53838   {
53839     try {
53840       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
53841     } catch (std::out_of_range& e) {
53842       {
53843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53844       };
53845     } catch (std::exception& e) {
53846       {
53847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53848       };
53849     } catch (...) {
53850       {
53851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53852       };
53853     }
53854   }
53855   jresult = (void *)result;
53856   return jresult;
53857 }
53858
53859
53860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
53861   Dali::Application *arg1 = (Dali::Application *) 0 ;
53862
53863   arg1 = (Dali::Application *)jarg1;
53864   {
53865     try {
53866       delete arg1;
53867     } catch (std::out_of_range& e) {
53868       {
53869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53870       };
53871     } catch (std::exception& e) {
53872       {
53873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53874       };
53875     } catch (...) {
53876       {
53877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53878       };
53879     }
53880   }
53881 }
53882
53883
53884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
53885   Dali::Application *arg1 = (Dali::Application *) 0 ;
53886
53887   arg1 = (Dali::Application *)jarg1;
53888   {
53889     try {
53890       (arg1)->MainLoop();
53891     } catch (std::out_of_range& e) {
53892       {
53893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53894       };
53895     } catch (std::exception& e) {
53896       {
53897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53898       };
53899     } catch (...) {
53900       {
53901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53902       };
53903     }
53904   }
53905 }
53906
53907
53908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
53909   Dali::Application *arg1 = (Dali::Application *) 0 ;
53910   Configuration::ContextLoss arg2 ;
53911   Configuration::ContextLoss *argp2 ;
53912
53913   arg1 = (Dali::Application *)jarg1;
53914   argp2 = (Configuration::ContextLoss *)jarg2;
53915   if (!argp2) {
53916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
53917     return ;
53918   }
53919   arg2 = *argp2;
53920   {
53921     try {
53922       (arg1)->MainLoop(arg2);
53923     } catch (std::out_of_range& e) {
53924       {
53925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53926       };
53927     } catch (std::exception& e) {
53928       {
53929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53930       };
53931     } catch (...) {
53932       {
53933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53934       };
53935     }
53936   }
53937 }
53938
53939
53940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
53941   Dali::Application *arg1 = (Dali::Application *) 0 ;
53942
53943   arg1 = (Dali::Application *)jarg1;
53944   {
53945     try {
53946       (arg1)->Lower();
53947     } catch (std::out_of_range& e) {
53948       {
53949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53950       };
53951     } catch (std::exception& e) {
53952       {
53953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53954       };
53955     } catch (...) {
53956       {
53957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53958       };
53959     }
53960   }
53961 }
53962
53963
53964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
53965   Dali::Application *arg1 = (Dali::Application *) 0 ;
53966
53967   arg1 = (Dali::Application *)jarg1;
53968   {
53969     try {
53970       (arg1)->Quit();
53971     } catch (std::out_of_range& e) {
53972       {
53973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53974       };
53975     } catch (std::exception& e) {
53976       {
53977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53978       };
53979     } catch (...) {
53980       {
53981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53982       };
53983     }
53984   }
53985 }
53986
53987
53988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
53989   unsigned int jresult ;
53990   Dali::Application *arg1 = (Dali::Application *) 0 ;
53991   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
53992   bool result;
53993
53994   arg1 = (Dali::Application *)jarg1;
53995   arg2 = (Dali::CallbackBase *)jarg2;
53996   {
53997     try {
53998       result = (bool)(arg1)->AddIdle(arg2);
53999     } catch (std::out_of_range& e) {
54000       {
54001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54002       };
54003     } catch (std::exception& e) {
54004       {
54005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54006       };
54007     } catch (...) {
54008       {
54009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54010       };
54011     }
54012   }
54013   jresult = result;
54014   return jresult;
54015 }
54016
54017
54018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54019   void * jresult ;
54020   Dali::Application *arg1 = (Dali::Application *) 0 ;
54021   Dali::Window result;
54022
54023   arg1 = (Dali::Application *)jarg1;
54024   {
54025     try {
54026       result = (arg1)->GetWindow();
54027     } catch (std::out_of_range& e) {
54028       {
54029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54030       };
54031     } catch (std::exception& e) {
54032       {
54033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54034       };
54035     } catch (...) {
54036       {
54037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54038       };
54039     }
54040   }
54041   jresult = new Dali::Window((const Dali::Window &)result);
54042   return jresult;
54043 }
54044
54045
54046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54047   Dali::Application *arg1 = (Dali::Application *) 0 ;
54048   Dali::PositionSize arg2 ;
54049   std::string *arg3 = 0 ;
54050   Dali::PositionSize *argp2 ;
54051
54052   arg1 = (Dali::Application *)jarg1;
54053   argp2 = (Dali::PositionSize *)jarg2;
54054   if (!argp2) {
54055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54056     return ;
54057   }
54058   arg2 = *argp2;
54059   if (!jarg3) {
54060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54061     return ;
54062   }
54063   std::string arg3_str(jarg3);
54064   arg3 = &arg3_str;
54065   {
54066     try {
54067       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54068     } catch (std::out_of_range& e) {
54069       {
54070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54071       };
54072     } catch (std::exception& e) {
54073       {
54074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54075       };
54076     } catch (...) {
54077       {
54078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54079       };
54080     }
54081   }
54082
54083   //argout typemap for const std::string&
54084
54085 }
54086
54087
54088 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54089   char * jresult ;
54090   std::string result;
54091
54092   {
54093     try {
54094       result = Dali::Application::GetResourcePath();
54095     } catch (std::out_of_range& e) {
54096       {
54097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54098       };
54099     } catch (std::exception& e) {
54100       {
54101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54102       };
54103     } catch (...) {
54104       {
54105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54106       };
54107     }
54108   }
54109   jresult = SWIG_csharp_string_callback((&result)->c_str());
54110   return jresult;
54111 }
54112
54113
54114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54115   Dali::Application *arg1 = (Dali::Application *) 0 ;
54116   Dali::ViewMode arg2 ;
54117
54118   arg1 = (Dali::Application *)jarg1;
54119   arg2 = (Dali::ViewMode)jarg2;
54120   {
54121     try {
54122       (arg1)->SetViewMode(arg2);
54123     } catch (std::out_of_range& e) {
54124       {
54125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54126       };
54127     } catch (std::exception& e) {
54128       {
54129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54130       };
54131     } catch (...) {
54132       {
54133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54134       };
54135     }
54136   }
54137 }
54138
54139
54140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54141   int jresult ;
54142   Dali::Application *arg1 = (Dali::Application *) 0 ;
54143   Dali::ViewMode result;
54144
54145   arg1 = (Dali::Application *)jarg1;
54146   {
54147     try {
54148       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54149     } catch (std::out_of_range& e) {
54150       {
54151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54152       };
54153     } catch (std::exception& e) {
54154       {
54155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54156       };
54157     } catch (...) {
54158       {
54159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54160       };
54161     }
54162   }
54163   jresult = (int)result;
54164   return jresult;
54165 }
54166
54167
54168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54169   Dali::Application *arg1 = (Dali::Application *) 0 ;
54170   float arg2 ;
54171
54172   arg1 = (Dali::Application *)jarg1;
54173   arg2 = (float)jarg2;
54174   {
54175     try {
54176       (arg1)->SetStereoBase(arg2);
54177     } catch (std::out_of_range& e) {
54178       {
54179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54180       };
54181     } catch (std::exception& e) {
54182       {
54183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54184       };
54185     } catch (...) {
54186       {
54187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54188       };
54189     }
54190   }
54191 }
54192
54193
54194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54195   float jresult ;
54196   Dali::Application *arg1 = (Dali::Application *) 0 ;
54197   float result;
54198
54199   arg1 = (Dali::Application *)jarg1;
54200   {
54201     try {
54202       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54203     } catch (std::out_of_range& e) {
54204       {
54205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54206       };
54207     } catch (std::exception& e) {
54208       {
54209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54210       };
54211     } catch (...) {
54212       {
54213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54214       };
54215     }
54216   }
54217   jresult = result;
54218   return jresult;
54219 }
54220
54221
54222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54223   void * jresult ;
54224   Dali::Application *arg1 = (Dali::Application *) 0 ;
54225   Dali::Application::AppSignalType *result = 0 ;
54226
54227   arg1 = (Dali::Application *)jarg1;
54228   {
54229     try {
54230       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54231     } catch (std::out_of_range& e) {
54232       {
54233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54234       };
54235     } catch (std::exception& e) {
54236       {
54237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54238       };
54239     } catch (...) {
54240       {
54241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54242       };
54243     }
54244   }
54245   jresult = (void *)result;
54246   return jresult;
54247 }
54248
54249
54250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54251   void * jresult ;
54252   Dali::Application *arg1 = (Dali::Application *) 0 ;
54253   Dali::Application::AppSignalType *result = 0 ;
54254
54255   arg1 = (Dali::Application *)jarg1;
54256   {
54257     try {
54258       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54259     } catch (std::out_of_range& e) {
54260       {
54261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54262       };
54263     } catch (std::exception& e) {
54264       {
54265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54266       };
54267     } catch (...) {
54268       {
54269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54270       };
54271     }
54272   }
54273   jresult = (void *)result;
54274   return jresult;
54275 }
54276
54277
54278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54279   void * jresult ;
54280   Dali::Application *arg1 = (Dali::Application *) 0 ;
54281   Dali::Application::AppSignalType *result = 0 ;
54282
54283   arg1 = (Dali::Application *)jarg1;
54284   {
54285     try {
54286       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54287     } catch (std::out_of_range& e) {
54288       {
54289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54290       };
54291     } catch (std::exception& e) {
54292       {
54293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54294       };
54295     } catch (...) {
54296       {
54297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54298       };
54299     }
54300   }
54301   jresult = (void *)result;
54302   return jresult;
54303 }
54304
54305
54306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
54307   void * jresult ;
54308   Dali::Application *arg1 = (Dali::Application *) 0 ;
54309   Dali::Application::AppSignalType *result = 0 ;
54310
54311   arg1 = (Dali::Application *)jarg1;
54312   {
54313     try {
54314       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
54315     } catch (std::out_of_range& e) {
54316       {
54317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54318       };
54319     } catch (std::exception& e) {
54320       {
54321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54322       };
54323     } catch (...) {
54324       {
54325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54326       };
54327     }
54328   }
54329   jresult = (void *)result;
54330   return jresult;
54331 }
54332
54333
54334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
54335   void * jresult ;
54336   Dali::Application *arg1 = (Dali::Application *) 0 ;
54337   Dali::Application::AppSignalType *result = 0 ;
54338
54339   arg1 = (Dali::Application *)jarg1;
54340   {
54341     try {
54342       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
54343     } catch (std::out_of_range& e) {
54344       {
54345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54346       };
54347     } catch (std::exception& e) {
54348       {
54349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54350       };
54351     } catch (...) {
54352       {
54353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54354       };
54355     }
54356   }
54357   jresult = (void *)result;
54358   return jresult;
54359 }
54360
54361
54362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
54363   void * jresult ;
54364   Dali::Application *arg1 = (Dali::Application *) 0 ;
54365   Dali::Application::AppSignalType *result = 0 ;
54366
54367   arg1 = (Dali::Application *)jarg1;
54368   {
54369     try {
54370       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
54371     } catch (std::out_of_range& e) {
54372       {
54373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54374       };
54375     } catch (std::exception& e) {
54376       {
54377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54378       };
54379     } catch (...) {
54380       {
54381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54382       };
54383     }
54384   }
54385   jresult = (void *)result;
54386   return jresult;
54387 }
54388
54389
54390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
54391   void * jresult ;
54392   Dali::Application *arg1 = (Dali::Application *) 0 ;
54393   Dali::Application::AppControlSignalType *result = 0 ;
54394
54395   arg1 = (Dali::Application *)jarg1;
54396   {
54397     try {
54398       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
54399     } catch (std::out_of_range& e) {
54400       {
54401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54402       };
54403     } catch (std::exception& e) {
54404       {
54405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54406       };
54407     } catch (...) {
54408       {
54409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54410       };
54411     }
54412   }
54413   jresult = (void *)result;
54414   return jresult;
54415 }
54416
54417
54418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
54419   void * jresult ;
54420   Dali::Application *arg1 = (Dali::Application *) 0 ;
54421   Dali::Application::AppSignalType *result = 0 ;
54422
54423   arg1 = (Dali::Application *)jarg1;
54424   {
54425     try {
54426       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
54427     } catch (std::out_of_range& e) {
54428       {
54429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54430       };
54431     } catch (std::exception& e) {
54432       {
54433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54434       };
54435     } catch (...) {
54436       {
54437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54438       };
54439     }
54440   }
54441   jresult = (void *)result;
54442   return jresult;
54443 }
54444
54445
54446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
54447   void * jresult ;
54448   Dali::Application *arg1 = (Dali::Application *) 0 ;
54449   Dali::Application::AppSignalType *result = 0 ;
54450
54451   arg1 = (Dali::Application *)jarg1;
54452   {
54453     try {
54454       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
54455     } catch (std::out_of_range& e) {
54456       {
54457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54458       };
54459     } catch (std::exception& e) {
54460       {
54461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54462       };
54463     } catch (...) {
54464       {
54465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54466       };
54467     }
54468   }
54469   jresult = (void *)result;
54470   return jresult;
54471 }
54472
54473
54474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
54475   void * jresult ;
54476   Dali::Application *arg1 = (Dali::Application *) 0 ;
54477   Dali::Application::AppSignalType *result = 0 ;
54478
54479   arg1 = (Dali::Application *)jarg1;
54480   {
54481     try {
54482       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
54483     } catch (std::out_of_range& e) {
54484       {
54485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54486       };
54487     } catch (std::exception& e) {
54488       {
54489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54490       };
54491     } catch (...) {
54492       {
54493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54494       };
54495     }
54496   }
54497   jresult = (void *)result;
54498   return jresult;
54499 }
54500
54501
54502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
54503   void * jresult ;
54504   Dali::Application *arg1 = (Dali::Application *) 0 ;
54505   Dali::Application::AppSignalType *result = 0 ;
54506
54507   arg1 = (Dali::Application *)jarg1;
54508   {
54509     try {
54510       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
54511     } catch (std::out_of_range& e) {
54512       {
54513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54514       };
54515     } catch (std::exception& e) {
54516       {
54517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54518       };
54519     } catch (...) {
54520       {
54521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54522       };
54523     }
54524   }
54525   jresult = (void *)result;
54526   return jresult;
54527 }
54528
54529
54530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
54531   unsigned int jresult ;
54532   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54533   bool result;
54534
54535   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54536   {
54537     try {
54538       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
54539     } catch (std::out_of_range& e) {
54540       {
54541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54542       };
54543     } catch (std::exception& e) {
54544       {
54545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54546       };
54547     } catch (...) {
54548       {
54549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54550       };
54551     }
54552   }
54553   jresult = result;
54554   return jresult;
54555 }
54556
54557
54558 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
54559   unsigned long jresult ;
54560   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54561   std::size_t result;
54562
54563   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54564   {
54565     try {
54566       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
54567     } catch (std::out_of_range& e) {
54568       {
54569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54570       };
54571     } catch (std::exception& e) {
54572       {
54573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54574       };
54575     } catch (...) {
54576       {
54577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54578       };
54579     }
54580   }
54581   jresult = (unsigned long)result;
54582   return jresult;
54583 }
54584
54585
54586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
54587   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54588   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
54589
54590   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54591   arg2 = (void (*)(Dali::Application &))jarg2;
54592   {
54593     try {
54594       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
54595     } catch (std::out_of_range& e) {
54596       {
54597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54598       };
54599     } catch (std::exception& e) {
54600       {
54601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54602       };
54603     } catch (...) {
54604       {
54605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54606       };
54607     }
54608   }
54609 }
54610
54611
54612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
54613   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54614   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
54615
54616   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54617   arg2 = (void (*)(Dali::Application &))jarg2;
54618   {
54619     try {
54620       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
54621     } catch (std::out_of_range& e) {
54622       {
54623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54624       };
54625     } catch (std::exception& e) {
54626       {
54627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54628       };
54629     } catch (...) {
54630       {
54631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54632       };
54633     }
54634   }
54635 }
54636
54637
54638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
54639   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54640   Dali::Application *arg2 = 0 ;
54641
54642   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54643   arg2 = (Dali::Application *)jarg2;
54644   if (!arg2) {
54645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
54646     return ;
54647   }
54648   {
54649     try {
54650       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
54651     } catch (std::out_of_range& e) {
54652       {
54653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54654       };
54655     } catch (std::exception& e) {
54656       {
54657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54658       };
54659     } catch (...) {
54660       {
54661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54662       };
54663     }
54664   }
54665 }
54666
54667
54668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
54669   void * jresult ;
54670   Dali::Signal< void (Dali::Application &) > *result = 0 ;
54671
54672   {
54673     try {
54674       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
54675     } catch (std::out_of_range& e) {
54676       {
54677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54678       };
54679     } catch (std::exception& e) {
54680       {
54681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54682       };
54683     } catch (...) {
54684       {
54685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54686       };
54687     }
54688   }
54689   jresult = (void *)result;
54690   return jresult;
54691 }
54692
54693
54694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
54695   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54696
54697   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54698   {
54699     try {
54700       delete arg1;
54701     } catch (std::out_of_range& e) {
54702       {
54703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54704       };
54705     } catch (std::exception& e) {
54706       {
54707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54708       };
54709     } catch (...) {
54710       {
54711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54712       };
54713     }
54714   }
54715 }
54716
54717
54718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
54719   unsigned int jresult ;
54720   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54721   bool result;
54722
54723   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54724   {
54725     try {
54726       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
54727     } catch (std::out_of_range& e) {
54728       {
54729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54730       };
54731     } catch (std::exception& e) {
54732       {
54733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54734       };
54735     } catch (...) {
54736       {
54737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54738       };
54739     }
54740   }
54741   jresult = result;
54742   return jresult;
54743 }
54744
54745
54746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
54747   unsigned long jresult ;
54748   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54749   std::size_t result;
54750
54751   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54752   {
54753     try {
54754       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
54755     } catch (std::out_of_range& e) {
54756       {
54757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54758       };
54759     } catch (std::exception& e) {
54760       {
54761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54762       };
54763     } catch (...) {
54764       {
54765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54766       };
54767     }
54768   }
54769   jresult = (unsigned long)result;
54770   return jresult;
54771 }
54772
54773
54774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
54775   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54776   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
54777
54778   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54779   arg2 = (void (*)(Dali::Application &,void *))jarg2;
54780   {
54781     try {
54782       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
54783     } catch (std::out_of_range& e) {
54784       {
54785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54786       };
54787     } catch (std::exception& e) {
54788       {
54789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54790       };
54791     } catch (...) {
54792       {
54793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54794       };
54795     }
54796   }
54797 }
54798
54799
54800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
54801   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54802   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
54803
54804   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54805   arg2 = (void (*)(Dali::Application &,void *))jarg2;
54806   {
54807     try {
54808       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
54809     } catch (std::out_of_range& e) {
54810       {
54811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54812       };
54813     } catch (std::exception& e) {
54814       {
54815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54816       };
54817     } catch (...) {
54818       {
54819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54820       };
54821     }
54822   }
54823 }
54824
54825
54826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54827   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54828   Dali::Application *arg2 = 0 ;
54829   void *arg3 = (void *) 0 ;
54830
54831   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54832   arg2 = (Dali::Application *)jarg2;
54833   if (!arg2) {
54834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
54835     return ;
54836   }
54837   arg3 = jarg3;
54838   {
54839     try {
54840       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
54841     } catch (std::out_of_range& e) {
54842       {
54843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54844       };
54845     } catch (std::exception& e) {
54846       {
54847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54848       };
54849     } catch (...) {
54850       {
54851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54852       };
54853     }
54854   }
54855 }
54856
54857
54858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
54859   void * jresult ;
54860   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
54861
54862   {
54863     try {
54864       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
54865     } catch (std::out_of_range& e) {
54866       {
54867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54868       };
54869     } catch (std::exception& e) {
54870       {
54871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54872       };
54873     } catch (...) {
54874       {
54875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54876       };
54877     }
54878   }
54879   jresult = (void *)result;
54880   return jresult;
54881 }
54882
54883
54884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
54885   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54886
54887   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54888   {
54889     try {
54890       delete arg1;
54891     } catch (std::out_of_range& e) {
54892       {
54893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54894       };
54895     } catch (std::exception& e) {
54896       {
54897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54898       };
54899     } catch (...) {
54900       {
54901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54902       };
54903     }
54904   }
54905 }
54906
54907
54908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
54909   void * jresult ;
54910   Dali::Signal< bool () > *result = 0 ;
54911
54912   {
54913     try {
54914       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
54915     } catch (std::out_of_range& e) {
54916       {
54917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54918       };
54919     } catch (std::exception& e) {
54920       {
54921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54922       };
54923     } catch (...) {
54924       {
54925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54926       };
54927     }
54928   }
54929   jresult = (void *)result;
54930   return jresult;
54931 }
54932
54933
54934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
54935   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54936
54937   arg1 = (Dali::Signal< bool () > *)jarg1;
54938   {
54939     try {
54940       delete arg1;
54941     } catch (std::out_of_range& e) {
54942       {
54943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54944       };
54945     } catch (std::exception& e) {
54946       {
54947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54948       };
54949     } catch (...) {
54950       {
54951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54952       };
54953     }
54954   }
54955 }
54956
54957
54958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
54959   unsigned int jresult ;
54960   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54961   bool result;
54962
54963   arg1 = (Dali::Signal< bool () > *)jarg1;
54964   {
54965     try {
54966       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
54967     } catch (std::out_of_range& e) {
54968       {
54969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54970       };
54971     } catch (std::exception& e) {
54972       {
54973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54974       };
54975     } catch (...) {
54976       {
54977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54978       };
54979     }
54980   }
54981   jresult = result;
54982   return jresult;
54983 }
54984
54985
54986 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
54987   unsigned long jresult ;
54988   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54989   std::size_t result;
54990
54991   arg1 = (Dali::Signal< bool () > *)jarg1;
54992   {
54993     try {
54994       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
54995     } catch (std::out_of_range& e) {
54996       {
54997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54998       };
54999     } catch (std::exception& e) {
55000       {
55001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55002       };
55003     } catch (...) {
55004       {
55005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55006       };
55007     }
55008   }
55009   jresult = (unsigned long)result;
55010   return jresult;
55011 }
55012
55013
55014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) {
55015   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55016   bool (*arg2)() = (bool (*)()) 0 ;
55017
55018   arg1 = (Dali::Signal< bool () > *)jarg1;
55019   arg2 = (bool (*)())jarg2;
55020   {
55021     try {
55022       (arg1)->Connect(arg2);
55023     } catch (std::out_of_range& e) {
55024       {
55025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55026       };
55027     } catch (std::exception& e) {
55028       {
55029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55030       };
55031     } catch (...) {
55032       {
55033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55034       };
55035     }
55036   }
55037 }
55038
55039
55040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55041   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55042   bool (*arg2)() = (bool (*)()) 0 ;
55043
55044   arg1 = (Dali::Signal< bool () > *)jarg1;
55045   arg2 = (bool (*)())jarg2;
55046   {
55047     try {
55048       (arg1)->Disconnect(arg2);
55049     } catch (std::out_of_range& e) {
55050       {
55051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55052       };
55053     } catch (std::exception& e) {
55054       {
55055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55056       };
55057     } catch (...) {
55058       {
55059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55060       };
55061     }
55062   }
55063 }
55064
55065
55066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
55067   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55068   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
55069   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
55070
55071   arg1 = (Dali::Signal< bool () > *)jarg1;
55072   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
55073   arg3 = (Dali::FunctorDelegate *)jarg3;
55074   {
55075     try {
55076       (arg1)->Connect(arg2,arg3);
55077     } catch (std::out_of_range& e) {
55078       {
55079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55080       };
55081     } catch (std::exception& e) {
55082       {
55083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55084       };
55085     } catch (...) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55088       };
55089     }
55090   }
55091 }
55092
55093
55094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55095   unsigned int jresult ;
55096   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55097   bool result;
55098
55099   arg1 = (Dali::Signal< bool () > *)jarg1;
55100   {
55101     try {
55102       result = (bool)(arg1)->Emit();
55103     } catch (std::out_of_range& e) {
55104       {
55105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55106       };
55107     } catch (std::exception& e) {
55108       {
55109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55110       };
55111     } catch (...) {
55112       {
55113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55114       };
55115     }
55116   }
55117   jresult = result;
55118   return jresult;
55119 }
55120
55121
55122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55123   int jresult ;
55124   int result;
55125
55126   {
55127     try {
55128       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55129     } catch (std::out_of_range& e) {
55130       {
55131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55132       };
55133     } catch (std::exception& e) {
55134       {
55135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55136       };
55137     } catch (...) {
55138       {
55139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55140       };
55141     }
55142   }
55143   jresult = (int)result;
55144   return jresult;
55145 }
55146
55147
55148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55149   int jresult ;
55150   int result;
55151
55152   {
55153     try {
55154       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55155     } catch (std::out_of_range& e) {
55156       {
55157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55158       };
55159     } catch (std::exception& e) {
55160       {
55161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55162       };
55163     } catch (...) {
55164       {
55165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55166       };
55167     }
55168   }
55169   jresult = (int)result;
55170   return jresult;
55171 }
55172
55173
55174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VERTEX_SHADER_get() {
55175   int jresult ;
55176   int result;
55177
55178   {
55179     try {
55180       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55181     } catch (std::out_of_range& e) {
55182       {
55183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55184       };
55185     } catch (std::exception& e) {
55186       {
55187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55188       };
55189     } catch (...) {
55190       {
55191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55192       };
55193     }
55194   }
55195   jresult = (int)result;
55196   return jresult;
55197 }
55198
55199
55200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FRAGMENT_SHADER_get() {
55201   int jresult ;
55202   int result;
55203
55204   {
55205     try {
55206       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55207     } catch (std::out_of_range& e) {
55208       {
55209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55210       };
55211     } catch (std::exception& e) {
55212       {
55213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55214       };
55215     } catch (...) {
55216       {
55217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55218       };
55219     }
55220   }
55221   jresult = (int)result;
55222   return jresult;
55223 }
55224
55225
55226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SUBDIVIDE_GRID_X_get() {
55227   int jresult ;
55228   int result;
55229
55230   {
55231     try {
55232       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55233     } catch (std::out_of_range& e) {
55234       {
55235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55236       };
55237     } catch (std::exception& e) {
55238       {
55239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55240       };
55241     } catch (...) {
55242       {
55243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55244       };
55245     }
55246   }
55247   jresult = (int)result;
55248   return jresult;
55249 }
55250
55251
55252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SUBDIVIDE_GRID_Y_get() {
55253   int jresult ;
55254   int result;
55255
55256   {
55257     try {
55258       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55259     } catch (std::out_of_range& e) {
55260       {
55261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55262       };
55263     } catch (std::exception& e) {
55264       {
55265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55266       };
55267     } catch (...) {
55268       {
55269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55270       };
55271     }
55272   }
55273   jresult = (int)result;
55274   return jresult;
55275 }
55276
55277
55278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_HINTS_get() {
55279   int jresult ;
55280   int result;
55281
55282   {
55283     try {
55284       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55285     } catch (std::out_of_range& e) {
55286       {
55287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55288       };
55289     } catch (std::exception& e) {
55290       {
55291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55292       };
55293     } catch (...) {
55294       {
55295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55296       };
55297     }
55298   }
55299   jresult = (int)result;
55300   return jresult;
55301 }
55302
55303
55304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_get() {
55305   int jresult ;
55306   int result;
55307
55308   {
55309     try {
55310       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55311     } catch (std::out_of_range& e) {
55312       {
55313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55314       };
55315     } catch (std::exception& e) {
55316       {
55317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55318       };
55319     } catch (...) {
55320       {
55321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55322       };
55323     }
55324   }
55325   jresult = (int)result;
55326   return jresult;
55327 }
55328
55329
55330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SIZE_get() {
55331   int jresult ;
55332   int result;
55333
55334   {
55335     try {
55336       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55337     } catch (std::out_of_range& e) {
55338       {
55339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55340       };
55341     } catch (std::exception& e) {
55342       {
55343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55344       };
55345     } catch (...) {
55346       {
55347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55348       };
55349     }
55350   }
55351   jresult = (int)result;
55352   return jresult;
55353 }
55354
55355
55356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ANTI_ALIASING_get() {
55357   int jresult ;
55358   int result;
55359
55360   {
55361     try {
55362       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55363     } catch (std::out_of_range& e) {
55364       {
55365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55366       };
55367     } catch (std::exception& e) {
55368       {
55369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55370       };
55371     } catch (...) {
55372       {
55373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55374       };
55375     }
55376   }
55377   jresult = (int)result;
55378   return jresult;
55379 }
55380
55381
55382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MIX_COLOR_get() {
55383   int jresult ;
55384   int result;
55385
55386   {
55387     try {
55388       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55389     } catch (std::out_of_range& e) {
55390       {
55391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55392       };
55393     } catch (std::exception& e) {
55394       {
55395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55396       };
55397     } catch (...) {
55398       {
55399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55400       };
55401     }
55402   }
55403   jresult = (int)result;
55404   return jresult;
55405 }
55406
55407
55408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_START_POSITION_get() {
55409   int jresult ;
55410   int result;
55411
55412   {
55413     try {
55414       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55415     } catch (std::out_of_range& e) {
55416       {
55417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55418       };
55419     } catch (std::exception& e) {
55420       {
55421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55422       };
55423     } catch (...) {
55424       {
55425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55426       };
55427     }
55428   }
55429   jresult = (int)result;
55430   return jresult;
55431 }
55432
55433
55434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_END_POSITION_get() {
55435   int jresult ;
55436   int result;
55437
55438   {
55439     try {
55440       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55441     } catch (std::out_of_range& e) {
55442       {
55443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55444       };
55445     } catch (std::exception& e) {
55446       {
55447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55448       };
55449     } catch (...) {
55450       {
55451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55452       };
55453     }
55454   }
55455   jresult = (int)result;
55456   return jresult;
55457 }
55458
55459
55460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CENTER_get() {
55461   int jresult ;
55462   int result;
55463
55464   {
55465     try {
55466       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55467     } catch (std::out_of_range& e) {
55468       {
55469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55470       };
55471     } catch (std::exception& e) {
55472       {
55473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55474       };
55475     } catch (...) {
55476       {
55477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55478       };
55479     }
55480   }
55481   jresult = (int)result;
55482   return jresult;
55483 }
55484
55485
55486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RADIUS_get() {
55487   int jresult ;
55488   int result;
55489
55490   {
55491     try {
55492       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55493     } catch (std::out_of_range& e) {
55494       {
55495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55496       };
55497     } catch (std::exception& e) {
55498       {
55499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55500       };
55501     } catch (...) {
55502       {
55503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55504       };
55505     }
55506   }
55507   jresult = (int)result;
55508   return jresult;
55509 }
55510
55511
55512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_STOP_OFFSET_get() {
55513   int jresult ;
55514   int result;
55515
55516   {
55517     try {
55518       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55519     } catch (std::out_of_range& e) {
55520       {
55521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55522       };
55523     } catch (std::exception& e) {
55524       {
55525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55526       };
55527     } catch (...) {
55528       {
55529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55530       };
55531     }
55532   }
55533   jresult = (int)result;
55534   return jresult;
55535 }
55536
55537
55538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_STOP_COLOR_get() {
55539   int jresult ;
55540   int result;
55541
55542   {
55543     try {
55544       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55545     } catch (std::out_of_range& e) {
55546       {
55547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55548       };
55549     } catch (std::exception& e) {
55550       {
55551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55552       };
55553     } catch (...) {
55554       {
55555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55556       };
55557     }
55558   }
55559   jresult = (int)result;
55560   return jresult;
55561 }
55562
55563
55564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_UNITS_get() {
55565   int jresult ;
55566   int result;
55567
55568   {
55569     try {
55570       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55571     } catch (std::out_of_range& e) {
55572       {
55573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55574       };
55575     } catch (std::exception& e) {
55576       {
55577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55578       };
55579     } catch (...) {
55580       {
55581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55582       };
55583     }
55584   }
55585   jresult = (int)result;
55586   return jresult;
55587 }
55588
55589
55590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SPREAD_METHOD_get() {
55591   int jresult ;
55592   int result;
55593
55594   {
55595     try {
55596       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55597     } catch (std::out_of_range& e) {
55598       {
55599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55600       };
55601     } catch (std::exception& e) {
55602       {
55603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55604       };
55605     } catch (...) {
55606       {
55607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55608       };
55609     }
55610   }
55611   jresult = (int)result;
55612   return jresult;
55613 }
55614
55615
55616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55617   int jresult ;
55618   int result;
55619
55620   {
55621     try {
55622       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55623     } catch (std::out_of_range& e) {
55624       {
55625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55626       };
55627     } catch (std::exception& e) {
55628       {
55629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55630       };
55631     } catch (...) {
55632       {
55633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55634       };
55635     }
55636   }
55637   jresult = (int)result;
55638   return jresult;
55639 }
55640
55641
55642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
55643   int jresult ;
55644   int result;
55645
55646   {
55647     try {
55648       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
55649     } catch (std::out_of_range& e) {
55650       {
55651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55652       };
55653     } catch (std::exception& e) {
55654       {
55655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55656       };
55657     } catch (...) {
55658       {
55659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55660       };
55661     }
55662   }
55663   jresult = (int)result;
55664   return jresult;
55665 }
55666
55667
55668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
55669   int jresult ;
55670   int result;
55671
55672   {
55673     try {
55674       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
55675     } catch (std::out_of_range& e) {
55676       {
55677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55678       };
55679     } catch (std::exception& e) {
55680       {
55681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55682       };
55683     } catch (...) {
55684       {
55685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55686       };
55687     }
55688   }
55689   jresult = (int)result;
55690   return jresult;
55691 }
55692
55693
55694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
55695   int jresult ;
55696   int result;
55697
55698   {
55699     try {
55700       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
55701     } catch (std::out_of_range& e) {
55702       {
55703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55704       };
55705     } catch (std::exception& e) {
55706       {
55707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55708       };
55709     } catch (...) {
55710       {
55711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55712       };
55713     }
55714   }
55715   jresult = (int)result;
55716   return jresult;
55717 }
55718
55719
55720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
55721   int jresult ;
55722   int result;
55723
55724   {
55725     try {
55726       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
55727     } catch (std::out_of_range& e) {
55728       {
55729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55730       };
55731     } catch (std::exception& e) {
55732       {
55733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55734       };
55735     } catch (...) {
55736       {
55737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55738       };
55739     }
55740   }
55741   jresult = (int)result;
55742   return jresult;
55743 }
55744
55745
55746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
55747   int jresult ;
55748   int result;
55749
55750   {
55751     try {
55752       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
55753     } catch (std::out_of_range& e) {
55754       {
55755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55756       };
55757     } catch (std::exception& e) {
55758       {
55759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55760       };
55761     } catch (...) {
55762       {
55763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55764       };
55765     }
55766   }
55767   jresult = (int)result;
55768   return jresult;
55769 }
55770
55771
55772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
55773   int jresult ;
55774   int result;
55775
55776   {
55777     try {
55778       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
55779     } catch (std::out_of_range& e) {
55780       {
55781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55782       };
55783     } catch (std::exception& e) {
55784       {
55785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55786       };
55787     } catch (...) {
55788       {
55789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55790       };
55791     }
55792   }
55793   jresult = (int)result;
55794   return jresult;
55795 }
55796
55797
55798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BATCHING_ENABLED_get() {
55799   int jresult ;
55800   int result;
55801
55802   {
55803     try {
55804       result = (int)Dali::Toolkit::ImageVisual::Property::BATCHING_ENABLED;
55805     } catch (std::out_of_range& e) {
55806       {
55807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55808       };
55809     } catch (std::exception& e) {
55810       {
55811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55812       };
55813     } catch (...) {
55814       {
55815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55816       };
55817     }
55818   }
55819   jresult = (int)result;
55820   return jresult;
55821 }
55822
55823
55824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PIXEL_AREA_get() {
55825   int jresult ;
55826   int result;
55827
55828   {
55829     try {
55830       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
55831     } catch (std::out_of_range& e) {
55832       {
55833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55834       };
55835     } catch (std::exception& e) {
55836       {
55837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55838       };
55839     } catch (...) {
55840       {
55841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55842       };
55843     }
55844   }
55845   jresult = (int)result;
55846   return jresult;
55847 }
55848
55849
55850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WRAP_MODE_U_get() {
55851   int jresult ;
55852   int result;
55853
55854   {
55855     try {
55856       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
55857     } catch (std::out_of_range& e) {
55858       {
55859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55860       };
55861     } catch (std::exception& e) {
55862       {
55863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55864       };
55865     } catch (...) {
55866       {
55867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55868       };
55869     }
55870   }
55871   jresult = (int)result;
55872   return jresult;
55873 }
55874
55875
55876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WRAP_MODE_V_get() {
55877   int jresult ;
55878   int result;
55879
55880   {
55881     try {
55882       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
55883     } catch (std::out_of_range& e) {
55884       {
55885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55886       };
55887     } catch (std::exception& e) {
55888       {
55889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55890       };
55891     } catch (...) {
55892       {
55893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55894       };
55895     }
55896   }
55897   jresult = (int)result;
55898   return jresult;
55899 }
55900
55901
55902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_OBJECT_URL_get() {
55903   int jresult ;
55904   int result;
55905
55906   {
55907     try {
55908       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
55909     } catch (std::out_of_range& e) {
55910       {
55911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55912       };
55913     } catch (std::exception& e) {
55914       {
55915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55916       };
55917     } catch (...) {
55918       {
55919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55920       };
55921     }
55922   }
55923   jresult = (int)result;
55924   return jresult;
55925 }
55926
55927
55928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MATERIAL_URL_get() {
55929   int jresult ;
55930   int result;
55931
55932   {
55933     try {
55934       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
55935     } catch (std::out_of_range& e) {
55936       {
55937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55938       };
55939     } catch (std::exception& e) {
55940       {
55941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55942       };
55943     } catch (...) {
55944       {
55945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55946       };
55947     }
55948   }
55949   jresult = (int)result;
55950   return jresult;
55951 }
55952
55953
55954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXTURES_PATH_get() {
55955   int jresult ;
55956   int result;
55957
55958   {
55959     try {
55960       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
55961     } catch (std::out_of_range& e) {
55962       {
55963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55964       };
55965     } catch (std::exception& e) {
55966       {
55967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55968       };
55969     } catch (...) {
55970       {
55971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55972       };
55973     }
55974   }
55975   jresult = (int)result;
55976   return jresult;
55977 }
55978
55979
55980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SHADING_MODE_get() {
55981   int jresult ;
55982   int result;
55983
55984   {
55985     try {
55986       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
55987     } catch (std::out_of_range& e) {
55988       {
55989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55990       };
55991     } catch (std::exception& e) {
55992       {
55993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55994       };
55995     } catch (...) {
55996       {
55997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55998       };
55999     }
56000   }
56001   jresult = (int)result;
56002   return jresult;
56003 }
56004
56005
56006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_USE_MIPMAPPING_get() {
56007   int jresult ;
56008   int result;
56009
56010   {
56011     try {
56012       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56013     } catch (std::out_of_range& e) {
56014       {
56015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56016       };
56017     } catch (std::exception& e) {
56018       {
56019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56020       };
56021     } catch (...) {
56022       {
56023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56024       };
56025     }
56026   }
56027   jresult = (int)result;
56028   return jresult;
56029 }
56030
56031
56032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_USE_SOFT_NORMALS_get() {
56033   int jresult ;
56034   int result;
56035
56036   {
56037     try {
56038       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56039     } catch (std::out_of_range& e) {
56040       {
56041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56042       };
56043     } catch (std::exception& e) {
56044       {
56045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56046       };
56047     } catch (...) {
56048       {
56049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56050       };
56051     }
56052   }
56053   jresult = (int)result;
56054   return jresult;
56055 }
56056
56057
56058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LIGHT_POSITION_get() {
56059   int jresult ;
56060   int result;
56061
56062   {
56063     try {
56064       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56065     } catch (std::out_of_range& e) {
56066       {
56067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56068       };
56069     } catch (std::exception& e) {
56070       {
56071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56072       };
56073     } catch (...) {
56074       {
56075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56076       };
56077     }
56078   }
56079   jresult = (int)result;
56080   return jresult;
56081 }
56082
56083
56084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SHAPE_get() {
56085   int jresult ;
56086   int result;
56087
56088   {
56089     try {
56090       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56091     } catch (std::out_of_range& e) {
56092       {
56093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56094       };
56095     } catch (std::exception& e) {
56096       {
56097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56098       };
56099     } catch (...) {
56100       {
56101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56102       };
56103     }
56104   }
56105   jresult = (int)result;
56106   return jresult;
56107 }
56108
56109
56110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56111   int jresult ;
56112   int result;
56113
56114   {
56115     try {
56116       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56117     } catch (std::out_of_range& e) {
56118       {
56119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56120       };
56121     } catch (std::exception& e) {
56122       {
56123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56124       };
56125     } catch (...) {
56126       {
56127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56128       };
56129     }
56130   }
56131   jresult = (int)result;
56132   return jresult;
56133 }
56134
56135
56136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SLICES_get() {
56137   int jresult ;
56138   int result;
56139
56140   {
56141     try {
56142       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56143     } catch (std::out_of_range& e) {
56144       {
56145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56146       };
56147     } catch (std::exception& e) {
56148       {
56149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56150       };
56151     } catch (...) {
56152       {
56153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56154       };
56155     }
56156   }
56157   jresult = (int)result;
56158   return jresult;
56159 }
56160
56161
56162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_STACKS_get() {
56163   int jresult ;
56164   int result;
56165
56166   {
56167     try {
56168       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56169     } catch (std::out_of_range& e) {
56170       {
56171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56172       };
56173     } catch (std::exception& e) {
56174       {
56175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56176       };
56177     } catch (...) {
56178       {
56179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56180       };
56181     }
56182   }
56183   jresult = (int)result;
56184   return jresult;
56185 }
56186
56187
56188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_TOP_RADIUS_get() {
56189   int jresult ;
56190   int result;
56191
56192   {
56193     try {
56194       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56195     } catch (std::out_of_range& e) {
56196       {
56197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56198       };
56199     } catch (std::exception& e) {
56200       {
56201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56202       };
56203     } catch (...) {
56204       {
56205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56206       };
56207     }
56208   }
56209   jresult = (int)result;
56210   return jresult;
56211 }
56212
56213
56214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_BOTTOM_RADIUS_get() {
56215   int jresult ;
56216   int result;
56217
56218   {
56219     try {
56220       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56221     } catch (std::out_of_range& e) {
56222       {
56223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56224       };
56225     } catch (std::exception& e) {
56226       {
56227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56228       };
56229     } catch (...) {
56230       {
56231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56232       };
56233     }
56234   }
56235   jresult = (int)result;
56236   return jresult;
56237 }
56238
56239
56240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_HEIGHT_get() {
56241   int jresult ;
56242   int result;
56243
56244   {
56245     try {
56246       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56247     } catch (std::out_of_range& e) {
56248       {
56249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56250       };
56251     } catch (std::exception& e) {
56252       {
56253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56254       };
56255     } catch (...) {
56256       {
56257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56258       };
56259     }
56260   }
56261   jresult = (int)result;
56262   return jresult;
56263 }
56264
56265
56266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_RADIUS_get() {
56267   int jresult ;
56268   int result;
56269
56270   {
56271     try {
56272       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56273     } catch (std::out_of_range& e) {
56274       {
56275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56276       };
56277     } catch (std::exception& e) {
56278       {
56279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56280       };
56281     } catch (...) {
56282       {
56283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56284       };
56285     }
56286   }
56287   jresult = (int)result;
56288   return jresult;
56289 }
56290
56291
56292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_SCALE_DIMENSIONS_get() {
56293   int jresult ;
56294   int result;
56295
56296   {
56297     try {
56298       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56299     } catch (std::out_of_range& e) {
56300       {
56301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56302       };
56303     } catch (std::exception& e) {
56304       {
56305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56306       };
56307     } catch (...) {
56308       {
56309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56310       };
56311     }
56312   }
56313   jresult = (int)result;
56314   return jresult;
56315 }
56316
56317
56318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BEVEL_PERCENTAGE_get() {
56319   int jresult ;
56320   int result;
56321
56322   {
56323     try {
56324       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56325     } catch (std::out_of_range& e) {
56326       {
56327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56328       };
56329     } catch (std::exception& e) {
56330       {
56331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56332       };
56333     } catch (...) {
56334       {
56335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56336       };
56337     }
56338   }
56339   jresult = (int)result;
56340   return jresult;
56341 }
56342
56343
56344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BEVEL_SMOOTHNESS_get() {
56345   int jresult ;
56346   int result;
56347
56348   {
56349     try {
56350       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56351     } catch (std::out_of_range& e) {
56352       {
56353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56354       };
56355     } catch (std::exception& e) {
56356       {
56357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56358       };
56359     } catch (...) {
56360       {
56361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56362       };
56363     }
56364   }
56365   jresult = (int)result;
56366   return jresult;
56367 }
56368
56369
56370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56371   int jresult ;
56372   int result;
56373
56374   {
56375     try {
56376       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56377     } catch (std::out_of_range& e) {
56378       {
56379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56380       };
56381     } catch (std::exception& e) {
56382       {
56383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56384       };
56385     } catch (...) {
56386       {
56387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56388       };
56389     }
56390   }
56391   jresult = (int)result;
56392   return jresult;
56393 }
56394
56395
56396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
56397   void * jresult ;
56398   Dali::Toolkit::Builder *result = 0 ;
56399
56400   {
56401     try {
56402       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
56403     } catch (std::out_of_range& e) {
56404       {
56405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56406       };
56407     } catch (std::exception& e) {
56408       {
56409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56410       };
56411     } catch (...) {
56412       {
56413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56414       };
56415     }
56416   }
56417   jresult = (void *)result;
56418   return jresult;
56419 }
56420
56421
56422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
56423   void * jresult ;
56424   Dali::Toolkit::Builder result;
56425
56426   {
56427     try {
56428       result = Dali::Toolkit::Builder::New();
56429     } catch (std::out_of_range& e) {
56430       {
56431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56432       };
56433     } catch (std::exception& e) {
56434       {
56435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56436       };
56437     } catch (...) {
56438       {
56439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56440       };
56441     }
56442   }
56443   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
56444   return jresult;
56445 }
56446
56447
56448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
56449   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56450
56451   arg1 = (Dali::Toolkit::Builder *)jarg1;
56452   {
56453     try {
56454       delete arg1;
56455     } catch (std::out_of_range& e) {
56456       {
56457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56458       };
56459     } catch (std::exception& e) {
56460       {
56461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56462       };
56463     } catch (...) {
56464       {
56465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56466       };
56467     }
56468   }
56469 }
56470
56471
56472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
56473   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56474   std::string *arg2 = 0 ;
56475   Dali::Toolkit::Builder::UIFormat arg3 ;
56476
56477   arg1 = (Dali::Toolkit::Builder *)jarg1;
56478   if (!jarg2) {
56479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56480     return ;
56481   }
56482   std::string arg2_str(jarg2);
56483   arg2 = &arg2_str;
56484   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
56485   {
56486     try {
56487       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
56488     } catch (std::out_of_range& e) {
56489       {
56490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56491       };
56492     } catch (std::exception& e) {
56493       {
56494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56495       };
56496     } catch (...) {
56497       {
56498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56499       };
56500     }
56501   }
56502
56503   //argout typemap for const std::string&
56504
56505 }
56506
56507
56508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
56509   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56510   std::string *arg2 = 0 ;
56511
56512   arg1 = (Dali::Toolkit::Builder *)jarg1;
56513   if (!jarg2) {
56514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56515     return ;
56516   }
56517   std::string arg2_str(jarg2);
56518   arg2 = &arg2_str;
56519   {
56520     try {
56521       (arg1)->LoadFromString((std::string const &)*arg2);
56522     } catch (std::out_of_range& e) {
56523       {
56524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56525       };
56526     } catch (std::exception& e) {
56527       {
56528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56529       };
56530     } catch (...) {
56531       {
56532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56533       };
56534     }
56535   }
56536
56537   //argout typemap for const std::string&
56538
56539 }
56540
56541
56542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
56543   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56544   Dali::Property::Map *arg2 = 0 ;
56545
56546   arg1 = (Dali::Toolkit::Builder *)jarg1;
56547   arg2 = (Dali::Property::Map *)jarg2;
56548   if (!arg2) {
56549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
56550     return ;
56551   }
56552   {
56553     try {
56554       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
56555     } catch (std::out_of_range& e) {
56556       {
56557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56558       };
56559     } catch (std::exception& e) {
56560       {
56561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56562       };
56563     } catch (...) {
56564       {
56565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56566       };
56567     }
56568   }
56569 }
56570
56571
56572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
56573   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56574   std::string *arg2 = 0 ;
56575   Dali::Property::Value *arg3 = 0 ;
56576
56577   arg1 = (Dali::Toolkit::Builder *)jarg1;
56578   if (!jarg2) {
56579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56580     return ;
56581   }
56582   std::string arg2_str(jarg2);
56583   arg2 = &arg2_str;
56584   arg3 = (Dali::Property::Value *)jarg3;
56585   if (!arg3) {
56586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
56587     return ;
56588   }
56589   {
56590     try {
56591       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
56592     } catch (std::out_of_range& e) {
56593       {
56594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56595       };
56596     } catch (std::exception& e) {
56597       {
56598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56599       };
56600     } catch (...) {
56601       {
56602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56603       };
56604     }
56605   }
56606
56607   //argout typemap for const std::string&
56608
56609 }
56610
56611
56612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
56613   void * jresult ;
56614   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56615   Dali::Property::Map *result = 0 ;
56616
56617   arg1 = (Dali::Toolkit::Builder *)jarg1;
56618   {
56619     try {
56620       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
56621     } catch (std::out_of_range& e) {
56622       {
56623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56624       };
56625     } catch (std::exception& e) {
56626       {
56627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56628       };
56629     } catch (...) {
56630       {
56631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56632       };
56633     }
56634   }
56635   jresult = (void *)result;
56636   return jresult;
56637 }
56638
56639
56640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
56641   void * jresult ;
56642   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56643   std::string *arg2 = 0 ;
56644   Dali::Property::Value *result = 0 ;
56645
56646   arg1 = (Dali::Toolkit::Builder *)jarg1;
56647   if (!jarg2) {
56648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56649     return 0;
56650   }
56651   std::string arg2_str(jarg2);
56652   arg2 = &arg2_str;
56653   {
56654     try {
56655       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
56656     } catch (std::out_of_range& e) {
56657       {
56658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56659       };
56660     } catch (std::exception& e) {
56661       {
56662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56663       };
56664     } catch (...) {
56665       {
56666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56667       };
56668     }
56669   }
56670   jresult = (void *)result;
56671
56672   //argout typemap for const std::string&
56673
56674   return jresult;
56675 }
56676
56677
56678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
56679   void * jresult ;
56680   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56681   std::string *arg2 = 0 ;
56682   Dali::Animation result;
56683
56684   arg1 = (Dali::Toolkit::Builder *)jarg1;
56685   if (!jarg2) {
56686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56687     return 0;
56688   }
56689   std::string arg2_str(jarg2);
56690   arg2 = &arg2_str;
56691   {
56692     try {
56693       result = (arg1)->CreateAnimation((std::string const &)*arg2);
56694     } catch (std::out_of_range& e) {
56695       {
56696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56697       };
56698     } catch (std::exception& e) {
56699       {
56700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56701       };
56702     } catch (...) {
56703       {
56704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56705       };
56706     }
56707   }
56708   jresult = new Dali::Animation((const Dali::Animation &)result);
56709
56710   //argout typemap for const std::string&
56711
56712   return jresult;
56713 }
56714
56715
56716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
56717   void * jresult ;
56718   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56719   std::string *arg2 = 0 ;
56720   Dali::Property::Map *arg3 = 0 ;
56721   Dali::Animation result;
56722
56723   arg1 = (Dali::Toolkit::Builder *)jarg1;
56724   if (!jarg2) {
56725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56726     return 0;
56727   }
56728   std::string arg2_str(jarg2);
56729   arg2 = &arg2_str;
56730   arg3 = (Dali::Property::Map *)jarg3;
56731   if (!arg3) {
56732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
56733     return 0;
56734   }
56735   {
56736     try {
56737       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
56738     } catch (std::out_of_range& e) {
56739       {
56740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56741       };
56742     } catch (std::exception& e) {
56743       {
56744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56745       };
56746     } catch (...) {
56747       {
56748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56749       };
56750     }
56751   }
56752   jresult = new Dali::Animation((const Dali::Animation &)result);
56753
56754   //argout typemap for const std::string&
56755
56756   return jresult;
56757 }
56758
56759
56760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
56761   void * jresult ;
56762   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56763   std::string *arg2 = 0 ;
56764   Dali::Actor arg3 ;
56765   Dali::Actor *argp3 ;
56766   Dali::Animation result;
56767
56768   arg1 = (Dali::Toolkit::Builder *)jarg1;
56769   if (!jarg2) {
56770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56771     return 0;
56772   }
56773   std::string arg2_str(jarg2);
56774   arg2 = &arg2_str;
56775   argp3 = (Dali::Actor *)jarg3;
56776   if (!argp3) {
56777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56778     return 0;
56779   }
56780   arg3 = *argp3;
56781   {
56782     try {
56783       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
56784     } catch (std::out_of_range& e) {
56785       {
56786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56787       };
56788     } catch (std::exception& e) {
56789       {
56790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56791       };
56792     } catch (...) {
56793       {
56794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56795       };
56796     }
56797   }
56798   jresult = new Dali::Animation((const Dali::Animation &)result);
56799
56800   //argout typemap for const std::string&
56801
56802   return jresult;
56803 }
56804
56805
56806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
56807   void * jresult ;
56808   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56809   std::string *arg2 = 0 ;
56810   Dali::Property::Map *arg3 = 0 ;
56811   Dali::Actor arg4 ;
56812   Dali::Actor *argp4 ;
56813   Dali::Animation result;
56814
56815   arg1 = (Dali::Toolkit::Builder *)jarg1;
56816   if (!jarg2) {
56817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56818     return 0;
56819   }
56820   std::string arg2_str(jarg2);
56821   arg2 = &arg2_str;
56822   arg3 = (Dali::Property::Map *)jarg3;
56823   if (!arg3) {
56824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
56825     return 0;
56826   }
56827   argp4 = (Dali::Actor *)jarg4;
56828   if (!argp4) {
56829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56830     return 0;
56831   }
56832   arg4 = *argp4;
56833   {
56834     try {
56835       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
56836     } catch (std::out_of_range& e) {
56837       {
56838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56839       };
56840     } catch (std::exception& e) {
56841       {
56842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56843       };
56844     } catch (...) {
56845       {
56846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56847       };
56848     }
56849   }
56850   jresult = new Dali::Animation((const Dali::Animation &)result);
56851
56852   //argout typemap for const std::string&
56853
56854   return jresult;
56855 }
56856
56857
56858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
56859   void * jresult ;
56860   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56861   std::string *arg2 = 0 ;
56862   Dali::BaseHandle result;
56863
56864   arg1 = (Dali::Toolkit::Builder *)jarg1;
56865   if (!jarg2) {
56866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56867     return 0;
56868   }
56869   std::string arg2_str(jarg2);
56870   arg2 = &arg2_str;
56871   {
56872     try {
56873       result = (arg1)->Create((std::string const &)*arg2);
56874     } catch (std::out_of_range& e) {
56875       {
56876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56877       };
56878     } catch (std::exception& e) {
56879       {
56880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56881       };
56882     } catch (...) {
56883       {
56884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56885       };
56886     }
56887   }
56888   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
56889
56890   //argout typemap for const std::string&
56891
56892   return jresult;
56893 }
56894
56895
56896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
56897   void * jresult ;
56898   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56899   std::string *arg2 = 0 ;
56900   Dali::Property::Map *arg3 = 0 ;
56901   Dali::BaseHandle result;
56902
56903   arg1 = (Dali::Toolkit::Builder *)jarg1;
56904   if (!jarg2) {
56905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56906     return 0;
56907   }
56908   std::string arg2_str(jarg2);
56909   arg2 = &arg2_str;
56910   arg3 = (Dali::Property::Map *)jarg3;
56911   if (!arg3) {
56912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
56913     return 0;
56914   }
56915   {
56916     try {
56917       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
56918     } catch (std::out_of_range& e) {
56919       {
56920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56921       };
56922     } catch (std::exception& e) {
56923       {
56924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56925       };
56926     } catch (...) {
56927       {
56928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56929       };
56930     }
56931   }
56932   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
56933
56934   //argout typemap for const std::string&
56935
56936   return jresult;
56937 }
56938
56939
56940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
56941   void * jresult ;
56942   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56943   std::string *arg2 = 0 ;
56944   Dali::BaseHandle result;
56945
56946   arg1 = (Dali::Toolkit::Builder *)jarg1;
56947   if (!jarg2) {
56948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56949     return 0;
56950   }
56951   std::string arg2_str(jarg2);
56952   arg2 = &arg2_str;
56953   {
56954     try {
56955       result = (arg1)->CreateFromJson((std::string const &)*arg2);
56956     } catch (std::out_of_range& e) {
56957       {
56958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56959       };
56960     } catch (std::exception& e) {
56961       {
56962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56963       };
56964     } catch (...) {
56965       {
56966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56967       };
56968     }
56969   }
56970   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
56971
56972   //argout typemap for const std::string&
56973
56974   return jresult;
56975 }
56976
56977
56978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
56979   unsigned int jresult ;
56980   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56981   std::string *arg2 = 0 ;
56982   Dali::Handle *arg3 = 0 ;
56983   bool result;
56984
56985   arg1 = (Dali::Toolkit::Builder *)jarg1;
56986   if (!jarg2) {
56987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56988     return 0;
56989   }
56990   std::string arg2_str(jarg2);
56991   arg2 = &arg2_str;
56992   arg3 = (Dali::Handle *)jarg3;
56993   if (!arg3) {
56994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
56995     return 0;
56996   }
56997   {
56998     try {
56999       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57000     } catch (std::out_of_range& e) {
57001       {
57002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57003       };
57004     } catch (std::exception& e) {
57005       {
57006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57007       };
57008     } catch (...) {
57009       {
57010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57011       };
57012     }
57013   }
57014   jresult = result;
57015
57016   //argout typemap for const std::string&
57017
57018   return jresult;
57019 }
57020
57021
57022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57023   unsigned int jresult ;
57024   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57025   Dali::Handle *arg2 = 0 ;
57026   std::string *arg3 = 0 ;
57027   bool result;
57028
57029   arg1 = (Dali::Toolkit::Builder *)jarg1;
57030   arg2 = (Dali::Handle *)jarg2;
57031   if (!arg2) {
57032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57033     return 0;
57034   }
57035   if (!jarg3) {
57036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57037     return 0;
57038   }
57039   std::string arg3_str(jarg3);
57040   arg3 = &arg3_str;
57041   {
57042     try {
57043       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57044     } catch (std::out_of_range& e) {
57045       {
57046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57047       };
57048     } catch (std::exception& e) {
57049       {
57050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57051       };
57052     } catch (...) {
57053       {
57054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57055       };
57056     }
57057   }
57058   jresult = result;
57059
57060   //argout typemap for const std::string&
57061
57062   return jresult;
57063 }
57064
57065
57066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57067   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57068   Dali::Actor arg2 ;
57069   Dali::Actor *argp2 ;
57070
57071   arg1 = (Dali::Toolkit::Builder *)jarg1;
57072   argp2 = (Dali::Actor *)jarg2;
57073   if (!argp2) {
57074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57075     return ;
57076   }
57077   arg2 = *argp2;
57078   {
57079     try {
57080       (arg1)->AddActors(arg2);
57081     } catch (std::out_of_range& e) {
57082       {
57083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57084       };
57085     } catch (std::exception& e) {
57086       {
57087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57088       };
57089     } catch (...) {
57090       {
57091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57092       };
57093     }
57094   }
57095 }
57096
57097
57098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57099   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57100   std::string *arg2 = 0 ;
57101   Dali::Actor arg3 ;
57102   Dali::Actor *argp3 ;
57103
57104   arg1 = (Dali::Toolkit::Builder *)jarg1;
57105   if (!jarg2) {
57106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57107     return ;
57108   }
57109   std::string arg2_str(jarg2);
57110   arg2 = &arg2_str;
57111   argp3 = (Dali::Actor *)jarg3;
57112   if (!argp3) {
57113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57114     return ;
57115   }
57116   arg3 = *argp3;
57117   {
57118     try {
57119       (arg1)->AddActors((std::string const &)*arg2,arg3);
57120     } catch (std::out_of_range& e) {
57121       {
57122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57123       };
57124     } catch (std::exception& e) {
57125       {
57126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57127       };
57128     } catch (...) {
57129       {
57130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57131       };
57132     }
57133   }
57134
57135   //argout typemap for const std::string&
57136
57137 }
57138
57139
57140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
57141   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57142   std::string *arg2 = 0 ;
57143
57144   arg1 = (Dali::Toolkit::Builder *)jarg1;
57145   if (!jarg2) {
57146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57147     return ;
57148   }
57149   std::string arg2_str(jarg2);
57150   arg2 = &arg2_str;
57151   {
57152     try {
57153       (arg1)->CreateRenderTask((std::string const &)*arg2);
57154     } catch (std::out_of_range& e) {
57155       {
57156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57157       };
57158     } catch (std::exception& e) {
57159       {
57160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57161       };
57162     } catch (...) {
57163       {
57164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57165       };
57166     }
57167   }
57168
57169   //argout typemap for const std::string&
57170
57171 }
57172
57173
57174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
57175   void * jresult ;
57176   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57177   std::string *arg2 = 0 ;
57178   Dali::FrameBufferImage result;
57179
57180   arg1 = (Dali::Toolkit::Builder *)jarg1;
57181   if (!jarg2) {
57182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57183     return 0;
57184   }
57185   std::string arg2_str(jarg2);
57186   arg2 = &arg2_str;
57187   {
57188     try {
57189       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
57190     } catch (std::out_of_range& e) {
57191       {
57192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57193       };
57194     } catch (std::exception& e) {
57195       {
57196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57197       };
57198     } catch (...) {
57199       {
57200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57201       };
57202     }
57203   }
57204   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
57205
57206   //argout typemap for const std::string&
57207
57208   return jresult;
57209 }
57210
57211
57212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
57213   void * jresult ;
57214   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57215   std::string *arg2 = 0 ;
57216   Dali::Path result;
57217
57218   arg1 = (Dali::Toolkit::Builder *)jarg1;
57219   if (!jarg2) {
57220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57221     return 0;
57222   }
57223   std::string arg2_str(jarg2);
57224   arg2 = &arg2_str;
57225   {
57226     try {
57227       result = (arg1)->GetPath((std::string const &)*arg2);
57228     } catch (std::out_of_range& e) {
57229       {
57230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57231       };
57232     } catch (std::exception& e) {
57233       {
57234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57235       };
57236     } catch (...) {
57237       {
57238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57239       };
57240     }
57241   }
57242   jresult = new Dali::Path((const Dali::Path &)result);
57243
57244   //argout typemap for const std::string&
57245
57246   return jresult;
57247 }
57248
57249
57250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
57251   void * jresult ;
57252   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57253   std::string *arg2 = 0 ;
57254   Dali::PathConstrainer result;
57255
57256   arg1 = (Dali::Toolkit::Builder *)jarg1;
57257   if (!jarg2) {
57258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57259     return 0;
57260   }
57261   std::string arg2_str(jarg2);
57262   arg2 = &arg2_str;
57263   {
57264     try {
57265       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
57266     } catch (std::out_of_range& e) {
57267       {
57268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57269       };
57270     } catch (std::exception& e) {
57271       {
57272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57273       };
57274     } catch (...) {
57275       {
57276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57277       };
57278     }
57279   }
57280   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
57281
57282   //argout typemap for const std::string&
57283
57284   return jresult;
57285 }
57286
57287
57288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
57289   void * jresult ;
57290   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57291   std::string *arg2 = 0 ;
57292   Dali::LinearConstrainer result;
57293
57294   arg1 = (Dali::Toolkit::Builder *)jarg1;
57295   if (!jarg2) {
57296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57297     return 0;
57298   }
57299   std::string arg2_str(jarg2);
57300   arg2 = &arg2_str;
57301   {
57302     try {
57303       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
57304     } catch (std::out_of_range& e) {
57305       {
57306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57307       };
57308     } catch (std::exception& e) {
57309       {
57310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57311       };
57312     } catch (...) {
57313       {
57314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57315       };
57316     }
57317   }
57318   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
57319
57320   //argout typemap for const std::string&
57321
57322   return jresult;
57323 }
57324
57325
57326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
57327   void * jresult ;
57328   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57329   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
57330
57331   arg1 = (Dali::Toolkit::Builder *)jarg1;
57332   {
57333     try {
57334       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
57335     } catch (std::out_of_range& e) {
57336       {
57337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57338       };
57339     } catch (std::exception& e) {
57340       {
57341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57342       };
57343     } catch (...) {
57344       {
57345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57346       };
57347     }
57348   }
57349   jresult = (void *)result;
57350   return jresult;
57351 }
57352
57353
57354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
57355   void * jresult ;
57356   Dali::Toolkit::Control result;
57357
57358   {
57359     try {
57360       result = Dali::Toolkit::Internal::Control::New();
57361     } catch (std::out_of_range& e) {
57362       {
57363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57364       };
57365     } catch (std::exception& e) {
57366       {
57367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57368       };
57369     } catch (...) {
57370       {
57371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57372       };
57373     }
57374   }
57375   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
57376   return jresult;
57377 }
57378
57379
57380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewImpl(void * jarg1) {
57381   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57382
57383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57384   {
57385     try {
57386       delete arg1;
57387     } catch (std::out_of_range& e) {
57388       {
57389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57390       };
57391     } catch (std::exception& e) {
57392       {
57393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57394       };
57395     } catch (...) {
57396       {
57397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57398       };
57399     }
57400   }
57401 }
57402
57403
57404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
57405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57406   std::string *arg2 = 0 ;
57407
57408   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57409   if (!jarg2) {
57410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57411     return ;
57412   }
57413   std::string arg2_str(jarg2);
57414   arg2 = &arg2_str;
57415   {
57416     try {
57417       (arg1)->SetStyleName((std::string const &)*arg2);
57418     } catch (std::out_of_range& e) {
57419       {
57420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57421       };
57422     } catch (std::exception& e) {
57423       {
57424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57425       };
57426     } catch (...) {
57427       {
57428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57429       };
57430     }
57431   }
57432
57433   //argout typemap for const std::string&
57434
57435 }
57436
57437
57438 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
57439   char * jresult ;
57440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57441   std::string *result = 0 ;
57442
57443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57444   {
57445     try {
57446       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
57447     } catch (std::out_of_range& e) {
57448       {
57449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57450       };
57451     } catch (std::exception& e) {
57452       {
57453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57454       };
57455     } catch (...) {
57456       {
57457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57458       };
57459     }
57460   }
57461   jresult = SWIG_csharp_string_callback(result->c_str());
57462   return jresult;
57463 }
57464
57465
57466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
57467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57468   Dali::Vector4 *arg2 = 0 ;
57469
57470   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57471   arg2 = (Dali::Vector4 *)jarg2;
57472   if (!arg2) {
57473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
57474     return ;
57475   }
57476   {
57477     try {
57478       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
57479     } catch (std::out_of_range& e) {
57480       {
57481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57482       };
57483     } catch (std::exception& e) {
57484       {
57485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57486       };
57487     } catch (...) {
57488       {
57489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57490       };
57491     }
57492   }
57493 }
57494
57495
57496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
57497   void * jresult ;
57498   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57499   Dali::Vector4 result;
57500
57501   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57502   {
57503     try {
57504       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
57505     } catch (std::out_of_range& e) {
57506       {
57507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57508       };
57509     } catch (std::exception& e) {
57510       {
57511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57512       };
57513     } catch (...) {
57514       {
57515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57516       };
57517     }
57518   }
57519   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
57520   return jresult;
57521 }
57522
57523
57524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
57525   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57526   Dali::Image arg2 ;
57527   Dali::Image *argp2 ;
57528
57529   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57530   argp2 = (Dali::Image *)jarg2;
57531   if (!argp2) {
57532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
57533     return ;
57534   }
57535   arg2 = *argp2;
57536   {
57537     try {
57538       (arg1)->SetBackgroundImage(arg2);
57539     } catch (std::out_of_range& e) {
57540       {
57541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57542       };
57543     } catch (std::exception& e) {
57544       {
57545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57546       };
57547     } catch (...) {
57548       {
57549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57550       };
57551     }
57552   }
57553 }
57554
57555
57556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
57557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57558   Dali::Property::Map *arg2 = 0 ;
57559
57560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57561   arg2 = (Dali::Property::Map *)jarg2;
57562   if (!arg2) {
57563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57564     return ;
57565   }
57566   {
57567     try {
57568       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
57569     } catch (std::out_of_range& e) {
57570       {
57571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57572       };
57573     } catch (std::exception& e) {
57574       {
57575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57576       };
57577     } catch (...) {
57578       {
57579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57580       };
57581     }
57582   }
57583 }
57584
57585
57586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
57587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57588
57589   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57590   {
57591     try {
57592       (arg1)->ClearBackground();
57593     } catch (std::out_of_range& e) {
57594       {
57595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57596       };
57597     } catch (std::exception& e) {
57598       {
57599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57600       };
57601     } catch (...) {
57602       {
57603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57604       };
57605     }
57606   }
57607 }
57608
57609
57610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
57611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57612   Dali::Gesture::Type arg2 ;
57613
57614   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57615   arg2 = (Dali::Gesture::Type)jarg2;
57616   {
57617     try {
57618       (arg1)->EnableGestureDetection(arg2);
57619     } catch (std::out_of_range& e) {
57620       {
57621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57622       };
57623     } catch (std::exception& e) {
57624       {
57625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57626       };
57627     } catch (...) {
57628       {
57629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57630       };
57631     }
57632   }
57633 }
57634
57635
57636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
57637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57638   Dali::Gesture::Type arg2 ;
57639
57640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57641   arg2 = (Dali::Gesture::Type)jarg2;
57642   {
57643     try {
57644       (arg1)->DisableGestureDetection(arg2);
57645     } catch (std::out_of_range& e) {
57646       {
57647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57648       };
57649     } catch (std::exception& e) {
57650       {
57651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57652       };
57653     } catch (...) {
57654       {
57655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57656       };
57657     }
57658   }
57659 }
57660
57661
57662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
57663   void * jresult ;
57664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57665   Dali::PinchGestureDetector result;
57666
57667   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57668   {
57669     try {
57670       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
57671     } catch (std::out_of_range& e) {
57672       {
57673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57674       };
57675     } catch (std::exception& e) {
57676       {
57677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57678       };
57679     } catch (...) {
57680       {
57681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57682       };
57683     }
57684   }
57685   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
57686   return jresult;
57687 }
57688
57689
57690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
57691   void * jresult ;
57692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57693   Dali::PanGestureDetector result;
57694
57695   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57696   {
57697     try {
57698       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
57699     } catch (std::out_of_range& e) {
57700       {
57701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57702       };
57703     } catch (std::exception& e) {
57704       {
57705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57706       };
57707     } catch (...) {
57708       {
57709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57710       };
57711     }
57712   }
57713   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
57714   return jresult;
57715 }
57716
57717
57718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
57719   void * jresult ;
57720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57721   Dali::TapGestureDetector result;
57722
57723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57724   {
57725     try {
57726       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
57727     } catch (std::out_of_range& e) {
57728       {
57729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57730       };
57731     } catch (std::exception& e) {
57732       {
57733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57734       };
57735     } catch (...) {
57736       {
57737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57738       };
57739     }
57740   }
57741   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
57742   return jresult;
57743 }
57744
57745
57746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
57747   void * jresult ;
57748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57749   Dali::LongPressGestureDetector result;
57750
57751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57752   {
57753     try {
57754       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
57755     } catch (std::out_of_range& e) {
57756       {
57757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57758       };
57759     } catch (std::exception& e) {
57760       {
57761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57762       };
57763     } catch (...) {
57764       {
57765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57766       };
57767     }
57768   }
57769   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
57770   return jresult;
57771 }
57772
57773
57774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
57775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57776   bool arg2 ;
57777
57778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57779   arg2 = jarg2 ? true : false;
57780   {
57781     try {
57782       (arg1)->SetKeyboardNavigationSupport(arg2);
57783     } catch (std::out_of_range& e) {
57784       {
57785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57786       };
57787     } catch (std::exception& e) {
57788       {
57789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57790       };
57791     } catch (...) {
57792       {
57793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57794       };
57795     }
57796   }
57797 }
57798
57799
57800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
57801   unsigned int jresult ;
57802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57803   bool result;
57804
57805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57806   {
57807     try {
57808       result = (bool)(arg1)->IsKeyboardNavigationSupported();
57809     } catch (std::out_of_range& e) {
57810       {
57811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57812       };
57813     } catch (std::exception& e) {
57814       {
57815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57816       };
57817     } catch (...) {
57818       {
57819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57820       };
57821     }
57822   }
57823   jresult = result;
57824   return jresult;
57825 }
57826
57827
57828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
57829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57830
57831   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57832   {
57833     try {
57834       (arg1)->SetKeyInputFocus();
57835     } catch (std::out_of_range& e) {
57836       {
57837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57838       };
57839     } catch (std::exception& e) {
57840       {
57841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57842       };
57843     } catch (...) {
57844       {
57845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57846       };
57847     }
57848   }
57849 }
57850
57851
57852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
57853   unsigned int jresult ;
57854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57855   bool result;
57856
57857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57858   {
57859     try {
57860       result = (bool)(arg1)->HasKeyInputFocus();
57861     } catch (std::out_of_range& e) {
57862       {
57863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57864       };
57865     } catch (std::exception& e) {
57866       {
57867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57868       };
57869     } catch (...) {
57870       {
57871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57872       };
57873     }
57874   }
57875   jresult = result;
57876   return jresult;
57877 }
57878
57879
57880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
57881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57882
57883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57884   {
57885     try {
57886       (arg1)->ClearKeyInputFocus();
57887     } catch (std::out_of_range& e) {
57888       {
57889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57890       };
57891     } catch (std::exception& e) {
57892       {
57893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57894       };
57895     } catch (...) {
57896       {
57897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57898       };
57899     }
57900   }
57901 }
57902
57903
57904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
57905   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57906   bool arg2 ;
57907
57908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57909   arg2 = jarg2 ? true : false;
57910   {
57911     try {
57912       (arg1)->SetAsKeyboardFocusGroup(arg2);
57913     } catch (std::out_of_range& e) {
57914       {
57915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57916       };
57917     } catch (std::exception& e) {
57918       {
57919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57920       };
57921     } catch (...) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57924       };
57925     }
57926   }
57927 }
57928
57929
57930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
57931   unsigned int jresult ;
57932   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57933   bool result;
57934
57935   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57936   {
57937     try {
57938       result = (bool)(arg1)->IsKeyboardFocusGroup();
57939     } catch (std::out_of_range& e) {
57940       {
57941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57942       };
57943     } catch (std::exception& e) {
57944       {
57945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57946       };
57947     } catch (...) {
57948       {
57949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57950       };
57951     }
57952   }
57953   jresult = result;
57954   return jresult;
57955 }
57956
57957
57958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
57959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57960
57961   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57962   {
57963     try {
57964       (arg1)->AccessibilityActivate();
57965     } catch (std::out_of_range& e) {
57966       {
57967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57968       };
57969     } catch (std::exception& e) {
57970       {
57971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57972       };
57973     } catch (...) {
57974       {
57975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57976       };
57977     }
57978   }
57979 }
57980
57981
57982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
57983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57984
57985   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57986   {
57987     try {
57988       (arg1)->KeyboardEnter();
57989     } catch (std::out_of_range& e) {
57990       {
57991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57992       };
57993     } catch (std::exception& e) {
57994       {
57995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57996       };
57997     } catch (...) {
57998       {
57999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58000       };
58001     }
58002   }
58003 }
58004
58005
58006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
58007   void * jresult ;
58008   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58009   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
58010
58011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58012   {
58013     try {
58014       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
58015     } catch (std::out_of_range& e) {
58016       {
58017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58018       };
58019     } catch (std::exception& e) {
58020       {
58021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58022       };
58023     } catch (...) {
58024       {
58025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58026       };
58027     }
58028   }
58029   jresult = (void *)result;
58030   return jresult;
58031 }
58032
58033
58034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
58035   void * jresult ;
58036   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58037   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58038
58039   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58040   {
58041     try {
58042       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
58043     } catch (std::out_of_range& e) {
58044       {
58045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58046       };
58047     } catch (std::exception& e) {
58048       {
58049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58050       };
58051     } catch (...) {
58052       {
58053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58054       };
58055     }
58056   }
58057   jresult = (void *)result;
58058   return jresult;
58059 }
58060
58061
58062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
58063   void * jresult ;
58064   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58065   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58066
58067   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58068   {
58069     try {
58070       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
58071     } catch (std::out_of_range& e) {
58072       {
58073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58074       };
58075     } catch (std::exception& e) {
58076       {
58077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58078       };
58079     } catch (...) {
58080       {
58081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58082       };
58083     }
58084   }
58085   jresult = (void *)result;
58086   return jresult;
58087 }
58088
58089
58090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
58091   unsigned int jresult ;
58092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58093   Dali::KeyEvent *arg2 = 0 ;
58094   bool result;
58095
58096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58097   arg2 = (Dali::KeyEvent *)jarg2;
58098   if (!arg2) {
58099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
58100     return 0;
58101   }
58102   {
58103     try {
58104       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
58105     } catch (std::out_of_range& e) {
58106       {
58107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58108       };
58109     } catch (std::exception& e) {
58110       {
58111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58112       };
58113     } catch (...) {
58114       {
58115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58116       };
58117     }
58118   }
58119   jresult = result;
58120   return jresult;
58121 }
58122
58123
58124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
58125   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58126
58127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58128   {
58129     try {
58130       (arg1)->OnInitialize();
58131     } catch (std::out_of_range& e) {
58132       {
58133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58134       };
58135     } catch (std::exception& e) {
58136       {
58137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58138       };
58139     } catch (...) {
58140       {
58141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58142       };
58143     }
58144   }
58145 }
58146
58147
58148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
58149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58150   Dali::Actor *arg2 = 0 ;
58151
58152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58153   arg2 = (Dali::Actor *)jarg2;
58154   if (!arg2) {
58155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
58156     return ;
58157   }
58158   {
58159     try {
58160       (arg1)->OnControlChildAdd(*arg2);
58161     } catch (std::out_of_range& e) {
58162       {
58163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58164       };
58165     } catch (std::exception& e) {
58166       {
58167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58168       };
58169     } catch (...) {
58170       {
58171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58172       };
58173     }
58174   }
58175 }
58176
58177
58178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
58179   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58180   Dali::Actor *arg2 = 0 ;
58181
58182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58183   arg2 = (Dali::Actor *)jarg2;
58184   if (!arg2) {
58185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
58186     return ;
58187   }
58188   {
58189     try {
58190       (arg1)->OnControlChildRemove(*arg2);
58191     } catch (std::out_of_range& e) {
58192       {
58193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58194       };
58195     } catch (std::exception& e) {
58196       {
58197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58198       };
58199     } catch (...) {
58200       {
58201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58202       };
58203     }
58204   }
58205 }
58206
58207
58208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
58209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58210   Dali::Toolkit::StyleManager arg2 ;
58211   Dali::StyleChange::Type arg3 ;
58212   Dali::Toolkit::StyleManager *argp2 ;
58213
58214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58215   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
58216   if (!argp2) {
58217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
58218     return ;
58219   }
58220   arg2 = *argp2;
58221   arg3 = (Dali::StyleChange::Type)jarg3;
58222   {
58223     try {
58224       (arg1)->OnStyleChange(arg2,arg3);
58225     } catch (std::out_of_range& e) {
58226       {
58227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58228       };
58229     } catch (std::exception& e) {
58230       {
58231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58232       };
58233     } catch (...) {
58234       {
58235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58236       };
58237     }
58238   }
58239 }
58240
58241
58242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
58243   unsigned int jresult ;
58244   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58245   bool result;
58246
58247   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58248   {
58249     try {
58250       result = (bool)(arg1)->OnAccessibilityActivated();
58251     } catch (std::out_of_range& e) {
58252       {
58253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58254       };
58255     } catch (std::exception& e) {
58256       {
58257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58258       };
58259     } catch (...) {
58260       {
58261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58262       };
58263     }
58264   }
58265   jresult = result;
58266   return jresult;
58267 }
58268
58269
58270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
58271   unsigned int jresult ;
58272   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58273   Dali::PanGesture arg2 ;
58274   Dali::PanGesture *argp2 ;
58275   bool result;
58276
58277   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58278   argp2 = (Dali::PanGesture *)jarg2;
58279   if (!argp2) {
58280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
58281     return 0;
58282   }
58283   arg2 = *argp2;
58284   {
58285     try {
58286       result = (bool)(arg1)->OnAccessibilityPan(arg2);
58287     } catch (std::out_of_range& e) {
58288       {
58289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58290       };
58291     } catch (std::exception& e) {
58292       {
58293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58294       };
58295     } catch (...) {
58296       {
58297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58298       };
58299     }
58300   }
58301   jresult = result;
58302   return jresult;
58303 }
58304
58305
58306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
58307   unsigned int jresult ;
58308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58309   Dali::TouchEvent *arg2 = 0 ;
58310   bool result;
58311
58312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58313   arg2 = (Dali::TouchEvent *)jarg2;
58314   if (!arg2) {
58315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
58316     return 0;
58317   }
58318   {
58319     try {
58320       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
58321     } catch (std::out_of_range& e) {
58322       {
58323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58324       };
58325     } catch (std::exception& e) {
58326       {
58327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58328       };
58329     } catch (...) {
58330       {
58331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58332       };
58333     }
58334   }
58335   jresult = result;
58336   return jresult;
58337 }
58338
58339
58340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
58341   unsigned int jresult ;
58342   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58343   bool arg2 ;
58344   bool result;
58345
58346   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58347   arg2 = jarg2 ? true : false;
58348   {
58349     try {
58350       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
58351     } catch (std::out_of_range& e) {
58352       {
58353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58354       };
58355     } catch (std::exception& e) {
58356       {
58357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58358       };
58359     } catch (...) {
58360       {
58361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58362       };
58363     }
58364   }
58365   jresult = result;
58366   return jresult;
58367 }
58368
58369
58370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
58371   unsigned int jresult ;
58372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58373   bool result;
58374
58375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58376   {
58377     try {
58378       result = (bool)(arg1)->OnAccessibilityZoom();
58379     } catch (std::out_of_range& e) {
58380       {
58381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58382       };
58383     } catch (std::exception& e) {
58384       {
58385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58386       };
58387     } catch (...) {
58388       {
58389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58390       };
58391     }
58392   }
58393   jresult = result;
58394   return jresult;
58395 }
58396
58397
58398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
58399   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58400
58401   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58402   {
58403     try {
58404       (arg1)->OnKeyInputFocusGained();
58405     } catch (std::out_of_range& e) {
58406       {
58407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58408       };
58409     } catch (std::exception& e) {
58410       {
58411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58412       };
58413     } catch (...) {
58414       {
58415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58416       };
58417     }
58418   }
58419 }
58420
58421
58422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
58423   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58424
58425   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58426   {
58427     try {
58428       (arg1)->OnKeyInputFocusLost();
58429     } catch (std::out_of_range& e) {
58430       {
58431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58432       };
58433     } catch (std::exception& e) {
58434       {
58435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58436       };
58437     } catch (...) {
58438       {
58439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58440       };
58441     }
58442   }
58443 }
58444
58445
58446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
58447   void * jresult ;
58448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58449   Dali::Actor arg2 ;
58450   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
58451   bool arg4 ;
58452   Dali::Actor *argp2 ;
58453   Dali::Actor result;
58454
58455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58456   argp2 = (Dali::Actor *)jarg2;
58457   if (!argp2) {
58458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58459     return 0;
58460   }
58461   arg2 = *argp2;
58462   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
58463   arg4 = jarg4 ? true : false;
58464   {
58465     try {
58466       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
58467     } catch (std::out_of_range& e) {
58468       {
58469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58470       };
58471     } catch (std::exception& e) {
58472       {
58473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58474       };
58475     } catch (...) {
58476       {
58477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58478       };
58479     }
58480   }
58481   jresult = new Dali::Actor((const Dali::Actor &)result);
58482   return jresult;
58483 }
58484
58485
58486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
58487   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58488   Dali::Actor arg2 ;
58489   Dali::Actor *argp2 ;
58490
58491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58492   argp2 = (Dali::Actor *)jarg2;
58493   if (!argp2) {
58494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58495     return ;
58496   }
58497   arg2 = *argp2;
58498   {
58499     try {
58500       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
58501     } catch (std::out_of_range& e) {
58502       {
58503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58504       };
58505     } catch (std::exception& e) {
58506       {
58507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58508       };
58509     } catch (...) {
58510       {
58511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58512       };
58513     }
58514   }
58515 }
58516
58517
58518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
58519   unsigned int jresult ;
58520   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58521   bool result;
58522
58523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58524   {
58525     try {
58526       result = (bool)(arg1)->OnKeyboardEnter();
58527     } catch (std::out_of_range& e) {
58528       {
58529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58530       };
58531     } catch (std::exception& e) {
58532       {
58533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58534       };
58535     } catch (...) {
58536       {
58537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58538       };
58539     }
58540   }
58541   jresult = result;
58542   return jresult;
58543 }
58544
58545
58546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
58547   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58548   Dali::PinchGesture *arg2 = 0 ;
58549
58550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58551   arg2 = (Dali::PinchGesture *)jarg2;
58552   if (!arg2) {
58553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
58554     return ;
58555   }
58556   {
58557     try {
58558       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
58559     } catch (std::out_of_range& e) {
58560       {
58561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58562       };
58563     } catch (std::exception& e) {
58564       {
58565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58566       };
58567     } catch (...) {
58568       {
58569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58570       };
58571     }
58572   }
58573 }
58574
58575
58576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
58577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58578   Dali::PanGesture *arg2 = 0 ;
58579
58580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58581   arg2 = (Dali::PanGesture *)jarg2;
58582   if (!arg2) {
58583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
58584     return ;
58585   }
58586   {
58587     try {
58588       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
58589     } catch (std::out_of_range& e) {
58590       {
58591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58592       };
58593     } catch (std::exception& e) {
58594       {
58595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58596       };
58597     } catch (...) {
58598       {
58599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58600       };
58601     }
58602   }
58603 }
58604
58605
58606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
58607   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58608   Dali::TapGesture *arg2 = 0 ;
58609
58610   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58611   arg2 = (Dali::TapGesture *)jarg2;
58612   if (!arg2) {
58613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
58614     return ;
58615   }
58616   {
58617     try {
58618       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
58619     } catch (std::out_of_range& e) {
58620       {
58621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58622       };
58623     } catch (std::exception& e) {
58624       {
58625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58626       };
58627     } catch (...) {
58628       {
58629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58630       };
58631     }
58632   }
58633 }
58634
58635
58636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
58637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58638   Dali::LongPressGesture *arg2 = 0 ;
58639
58640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58641   arg2 = (Dali::LongPressGesture *)jarg2;
58642   if (!arg2) {
58643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
58644     return ;
58645   }
58646   {
58647     try {
58648       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
58649     } catch (std::out_of_range& e) {
58650       {
58651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58652       };
58653     } catch (std::exception& e) {
58654       {
58655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58656       };
58657     } catch (...) {
58658       {
58659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58660       };
58661     }
58662   }
58663 }
58664
58665
58666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
58667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58668   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58669   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58670
58671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58672   arg2 = (Dali::SlotObserver *)jarg2;
58673   arg3 = (Dali::CallbackBase *)jarg3;
58674   {
58675     try {
58676       (arg1)->SignalConnected(arg2,arg3);
58677     } catch (std::out_of_range& e) {
58678       {
58679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58680       };
58681     } catch (std::exception& e) {
58682       {
58683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58684       };
58685     } catch (...) {
58686       {
58687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58688       };
58689     }
58690   }
58691 }
58692
58693
58694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58695   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58696   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58697   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58698
58699   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58700   arg2 = (Dali::SlotObserver *)jarg2;
58701   arg3 = (Dali::CallbackBase *)jarg3;
58702   {
58703     try {
58704       (arg1)->SignalDisconnected(arg2,arg3);
58705     } catch (std::out_of_range& e) {
58706       {
58707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58708       };
58709     } catch (std::exception& e) {
58710       {
58711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58712       };
58713     } catch (...) {
58714       {
58715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58716       };
58717     }
58718   }
58719 }
58720
58721
58722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
58723   void * jresult ;
58724   Dali::Toolkit::Control *arg1 = 0 ;
58725   Dali::Toolkit::Internal::Control *result = 0 ;
58726
58727   arg1 = (Dali::Toolkit::Control *)jarg1;
58728   if (!arg1) {
58729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58730     return 0;
58731   }
58732   {
58733     try {
58734       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
58735     } catch (std::out_of_range& e) {
58736       {
58737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58738       };
58739     } catch (std::exception& e) {
58740       {
58741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58742       };
58743     } catch (...) {
58744       {
58745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58746       };
58747     }
58748   }
58749   jresult = (void *)result;
58750   return jresult;
58751 }
58752
58753
58754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
58755   int jresult ;
58756   int result;
58757
58758   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
58759   jresult = (int)result;
58760   return jresult;
58761 }
58762
58763
58764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
58765   int jresult ;
58766   int result;
58767
58768   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
58769   jresult = (int)result;
58770   return jresult;
58771 }
58772
58773
58774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
58775   int jresult ;
58776   int result;
58777
58778   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
58779   jresult = (int)result;
58780   return jresult;
58781 }
58782
58783
58784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
58785   int jresult ;
58786   int result;
58787
58788   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
58789   jresult = (int)result;
58790   return jresult;
58791 }
58792
58793
58794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
58795   int jresult ;
58796   int result;
58797
58798   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
58799   jresult = (int)result;
58800   return jresult;
58801 }
58802
58803
58804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
58805   void * jresult ;
58806   Dali::Toolkit::Control::Property *result = 0 ;
58807
58808   {
58809     try {
58810       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
58811     } catch (std::out_of_range& e) {
58812       {
58813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58814       };
58815     } catch (std::exception& e) {
58816       {
58817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58818       };
58819     } catch (...) {
58820       {
58821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58822       };
58823     }
58824   }
58825   jresult = (void *)result;
58826   return jresult;
58827 }
58828
58829
58830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
58831   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
58832
58833   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
58834   {
58835     try {
58836       delete arg1;
58837     } catch (std::out_of_range& e) {
58838       {
58839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58840       };
58841     } catch (std::exception& e) {
58842       {
58843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58844       };
58845     } catch (...) {
58846       {
58847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58848       };
58849     }
58850   }
58851 }
58852
58853
58854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
58855   void * jresult ;
58856   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
58857
58858   {
58859     try {
58860       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
58861     } catch (std::out_of_range& e) {
58862       {
58863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58864       };
58865     } catch (std::exception& e) {
58866       {
58867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58868       };
58869     } catch (...) {
58870       {
58871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58872       };
58873     }
58874   }
58875   jresult = (void *)result;
58876   return jresult;
58877 }
58878
58879
58880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
58881   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
58882
58883   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
58884   {
58885     try {
58886       delete arg1;
58887     } catch (std::out_of_range& e) {
58888       {
58889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58890       };
58891     } catch (std::exception& e) {
58892       {
58893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58894       };
58895     } catch (...) {
58896       {
58897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58898       };
58899     }
58900   }
58901 }
58902
58903
58904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
58905   void * jresult ;
58906   Dali::Toolkit::Control result;
58907
58908   {
58909     try {
58910       result = Dali::Toolkit::Control::New();
58911     } catch (std::out_of_range& e) {
58912       {
58913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58914       };
58915     } catch (std::exception& e) {
58916       {
58917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58918       };
58919     } catch (...) {
58920       {
58921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58922       };
58923     }
58924   }
58925   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58926   return jresult;
58927 }
58928
58929
58930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
58931   void * jresult ;
58932   Dali::Toolkit::Control *result = 0 ;
58933
58934   {
58935     try {
58936       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
58937     } catch (std::out_of_range& e) {
58938       {
58939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58940       };
58941     } catch (std::exception& e) {
58942       {
58943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58944       };
58945     } catch (...) {
58946       {
58947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58948       };
58949     }
58950   }
58951   jresult = (void *)result;
58952   return jresult;
58953 }
58954
58955
58956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
58957   void * jresult ;
58958   Dali::Toolkit::Control *arg1 = 0 ;
58959   Dali::Toolkit::Control *result = 0 ;
58960
58961   arg1 = (Dali::Toolkit::Control *)jarg1;
58962   if (!arg1) {
58963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58964     return 0;
58965   }
58966   {
58967     try {
58968       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
58969     } catch (std::out_of_range& e) {
58970       {
58971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58972       };
58973     } catch (std::exception& e) {
58974       {
58975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58976       };
58977     } catch (...) {
58978       {
58979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58980       };
58981     }
58982   }
58983   jresult = (void *)result;
58984   return jresult;
58985 }
58986
58987
58988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
58989   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58990
58991   arg1 = (Dali::Toolkit::Control *)jarg1;
58992   {
58993     try {
58994       delete arg1;
58995     } catch (std::out_of_range& e) {
58996       {
58997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58998       };
58999     } catch (std::exception& e) {
59000       {
59001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59002       };
59003     } catch (...) {
59004       {
59005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59006       };
59007     }
59008   }
59009 }
59010
59011
59012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
59013   void * jresult ;
59014   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59015   Dali::Toolkit::Control *arg2 = 0 ;
59016   Dali::Toolkit::Control *result = 0 ;
59017
59018   arg1 = (Dali::Toolkit::Control *)jarg1;
59019   arg2 = (Dali::Toolkit::Control *)jarg2;
59020   if (!arg2) {
59021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
59022     return 0;
59023   }
59024   {
59025     try {
59026       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
59027     } catch (std::out_of_range& e) {
59028       {
59029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59030       };
59031     } catch (std::exception& e) {
59032       {
59033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59034       };
59035     } catch (...) {
59036       {
59037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59038       };
59039     }
59040   }
59041   jresult = (void *)result;
59042   return jresult;
59043 }
59044
59045
59046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
59047   void * jresult ;
59048   Dali::BaseHandle arg1 ;
59049   Dali::BaseHandle *argp1 ;
59050   Dali::Toolkit::Control result;
59051
59052   argp1 = (Dali::BaseHandle *)jarg1;
59053   if (!argp1) {
59054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59055     return 0;
59056   }
59057   arg1 = *argp1;
59058   {
59059     try {
59060       result = Dali::Toolkit::Control::DownCast(arg1);
59061     } catch (std::out_of_range& e) {
59062       {
59063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59064       };
59065     } catch (std::exception& e) {
59066       {
59067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59068       };
59069     } catch (...) {
59070       {
59071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59072       };
59073     }
59074   }
59075   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59076   return jresult;
59077 }
59078
59079
59080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
59081   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59082
59083   arg1 = (Dali::Toolkit::Control *)jarg1;
59084   {
59085     try {
59086       (arg1)->SetKeyInputFocus();
59087     } catch (std::out_of_range& e) {
59088       {
59089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59090       };
59091     } catch (std::exception& e) {
59092       {
59093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59094       };
59095     } catch (...) {
59096       {
59097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59098       };
59099     }
59100   }
59101 }
59102
59103
59104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
59105   unsigned int jresult ;
59106   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59107   bool result;
59108
59109   arg1 = (Dali::Toolkit::Control *)jarg1;
59110   {
59111     try {
59112       result = (bool)(arg1)->HasKeyInputFocus();
59113     } catch (std::out_of_range& e) {
59114       {
59115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59116       };
59117     } catch (std::exception& e) {
59118       {
59119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59120       };
59121     } catch (...) {
59122       {
59123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59124       };
59125     }
59126   }
59127   jresult = result;
59128   return jresult;
59129 }
59130
59131
59132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
59133   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59134
59135   arg1 = (Dali::Toolkit::Control *)jarg1;
59136   {
59137     try {
59138       (arg1)->ClearKeyInputFocus();
59139     } catch (std::out_of_range& e) {
59140       {
59141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59142       };
59143     } catch (std::exception& e) {
59144       {
59145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59146       };
59147     } catch (...) {
59148       {
59149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59150       };
59151     }
59152   }
59153 }
59154
59155
59156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
59157   void * jresult ;
59158   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59159   Dali::PinchGestureDetector result;
59160
59161   arg1 = (Dali::Toolkit::Control *)jarg1;
59162   {
59163     try {
59164       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
59165     } catch (std::out_of_range& e) {
59166       {
59167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59168       };
59169     } catch (std::exception& e) {
59170       {
59171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59172       };
59173     } catch (...) {
59174       {
59175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59176       };
59177     }
59178   }
59179   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59180   return jresult;
59181 }
59182
59183
59184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
59185   void * jresult ;
59186   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59187   Dali::PanGestureDetector result;
59188
59189   arg1 = (Dali::Toolkit::Control *)jarg1;
59190   {
59191     try {
59192       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
59193     } catch (std::out_of_range& e) {
59194       {
59195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59196       };
59197     } catch (std::exception& e) {
59198       {
59199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59200       };
59201     } catch (...) {
59202       {
59203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59204       };
59205     }
59206   }
59207   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59208   return jresult;
59209 }
59210
59211
59212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
59213   void * jresult ;
59214   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59215   Dali::TapGestureDetector result;
59216
59217   arg1 = (Dali::Toolkit::Control *)jarg1;
59218   {
59219     try {
59220       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
59221     } catch (std::out_of_range& e) {
59222       {
59223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59224       };
59225     } catch (std::exception& e) {
59226       {
59227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59228       };
59229     } catch (...) {
59230       {
59231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59232       };
59233     }
59234   }
59235   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59236   return jresult;
59237 }
59238
59239
59240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
59241   void * jresult ;
59242   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59243   Dali::LongPressGestureDetector result;
59244
59245   arg1 = (Dali::Toolkit::Control *)jarg1;
59246   {
59247     try {
59248       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
59249     } catch (std::out_of_range& e) {
59250       {
59251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59252       };
59253     } catch (std::exception& e) {
59254       {
59255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59256       };
59257     } catch (...) {
59258       {
59259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59260       };
59261     }
59262   }
59263   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59264   return jresult;
59265 }
59266
59267
59268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
59269   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59270   std::string *arg2 = 0 ;
59271
59272   arg1 = (Dali::Toolkit::Control *)jarg1;
59273   if (!jarg2) {
59274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59275     return ;
59276   }
59277   std::string arg2_str(jarg2);
59278   arg2 = &arg2_str;
59279   {
59280     try {
59281       (arg1)->SetStyleName((std::string const &)*arg2);
59282     } catch (std::out_of_range& e) {
59283       {
59284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59285       };
59286     } catch (std::exception& e) {
59287       {
59288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59289       };
59290     } catch (...) {
59291       {
59292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59293       };
59294     }
59295   }
59296
59297   //argout typemap for const std::string&
59298
59299 }
59300
59301
59302 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
59303   char * jresult ;
59304   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59305   std::string *result = 0 ;
59306
59307   arg1 = (Dali::Toolkit::Control *)jarg1;
59308   {
59309     try {
59310       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
59311     } catch (std::out_of_range& e) {
59312       {
59313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59314       };
59315     } catch (std::exception& e) {
59316       {
59317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59318       };
59319     } catch (...) {
59320       {
59321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59322       };
59323     }
59324   }
59325   jresult = SWIG_csharp_string_callback(result->c_str());
59326   return jresult;
59327 }
59328
59329
59330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
59331   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59332   Dali::Vector4 *arg2 = 0 ;
59333
59334   arg1 = (Dali::Toolkit::Control *)jarg1;
59335   arg2 = (Dali::Vector4 *)jarg2;
59336   if (!arg2) {
59337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59338     return ;
59339   }
59340   {
59341     try {
59342       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59343     } catch (std::out_of_range& e) {
59344       {
59345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59346       };
59347     } catch (std::exception& e) {
59348       {
59349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59350       };
59351     } catch (...) {
59352       {
59353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59354       };
59355     }
59356   }
59357 }
59358
59359
59360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
59361   void * jresult ;
59362   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59363   Dali::Vector4 result;
59364
59365   arg1 = (Dali::Toolkit::Control *)jarg1;
59366   {
59367     try {
59368       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
59369     } catch (std::out_of_range& e) {
59370       {
59371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59372       };
59373     } catch (std::exception& e) {
59374       {
59375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59376       };
59377     } catch (...) {
59378       {
59379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59380       };
59381     }
59382   }
59383   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59384   return jresult;
59385 }
59386
59387
59388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
59389   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59390   Dali::Image arg2 ;
59391   Dali::Image *argp2 ;
59392
59393   arg1 = (Dali::Toolkit::Control *)jarg1;
59394   argp2 = (Dali::Image *)jarg2;
59395   if (!argp2) {
59396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59397     return ;
59398   }
59399   arg2 = *argp2;
59400   {
59401     try {
59402       (arg1)->SetBackgroundImage(arg2);
59403     } catch (std::out_of_range& e) {
59404       {
59405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59406       };
59407     } catch (std::exception& e) {
59408       {
59409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59410       };
59411     } catch (...) {
59412       {
59413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59414       };
59415     }
59416   }
59417 }
59418
59419
59420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
59421   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59422
59423   arg1 = (Dali::Toolkit::Control *)jarg1;
59424   {
59425     try {
59426       (arg1)->ClearBackground();
59427     } catch (std::out_of_range& e) {
59428       {
59429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59430       };
59431     } catch (std::exception& e) {
59432       {
59433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59434       };
59435     } catch (...) {
59436       {
59437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59438       };
59439     }
59440   }
59441 }
59442
59443
59444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
59445   void * jresult ;
59446   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59447   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59448
59449   arg1 = (Dali::Toolkit::Control *)jarg1;
59450   {
59451     try {
59452       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59453     } catch (std::out_of_range& e) {
59454       {
59455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59456       };
59457     } catch (std::exception& e) {
59458       {
59459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59460       };
59461     } catch (...) {
59462       {
59463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59464       };
59465     }
59466   }
59467   jresult = (void *)result;
59468   return jresult;
59469 }
59470
59471
59472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
59473   void * jresult ;
59474   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59475   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59476
59477   arg1 = (Dali::Toolkit::Control *)jarg1;
59478   {
59479     try {
59480       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59481     } catch (std::out_of_range& e) {
59482       {
59483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59484       };
59485     } catch (std::exception& e) {
59486       {
59487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59488       };
59489     } catch (...) {
59490       {
59491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59492       };
59493     }
59494   }
59495   jresult = (void *)result;
59496   return jresult;
59497 }
59498
59499
59500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
59501   void * jresult ;
59502   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59503   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59504
59505   arg1 = (Dali::Toolkit::Control *)jarg1;
59506   {
59507     try {
59508       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59509     } catch (std::out_of_range& e) {
59510       {
59511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59512       };
59513     } catch (std::exception& e) {
59514       {
59515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59516       };
59517     } catch (...) {
59518       {
59519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59520       };
59521     }
59522   }
59523   jresult = (void *)result;
59524   return jresult;
59525 }
59526
59527
59528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
59529   void * jresult ;
59530   Dali::Toolkit::Internal::Control *arg1 = 0 ;
59531   Dali::Toolkit::Control *result = 0 ;
59532
59533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59534   if (!arg1) {
59535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
59536     return 0;
59537   }
59538   {
59539     try {
59540       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
59541     } catch (std::out_of_range& e) {
59542       {
59543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59544       };
59545     } catch (std::exception& e) {
59546       {
59547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59548       };
59549     } catch (...) {
59550       {
59551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59552       };
59553     }
59554   }
59555   jresult = (void *)result;
59556   return jresult;
59557 }
59558
59559
59560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
59561   void * jresult ;
59562   Dali::Toolkit::Alignment::Padding *result = 0 ;
59563
59564   {
59565     try {
59566       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
59567     } catch (std::out_of_range& e) {
59568       {
59569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59570       };
59571     } catch (std::exception& e) {
59572       {
59573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59574       };
59575     } catch (...) {
59576       {
59577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59578       };
59579     }
59580   }
59581   jresult = (void *)result;
59582   return jresult;
59583 }
59584
59585
59586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
59587   void * jresult ;
59588   float arg1 ;
59589   float arg2 ;
59590   float arg3 ;
59591   float arg4 ;
59592   Dali::Toolkit::Alignment::Padding *result = 0 ;
59593
59594   arg1 = (float)jarg1;
59595   arg2 = (float)jarg2;
59596   arg3 = (float)jarg3;
59597   arg4 = (float)jarg4;
59598   {
59599     try {
59600       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
59601     } catch (std::out_of_range& e) {
59602       {
59603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59604       };
59605     } catch (std::exception& e) {
59606       {
59607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59608       };
59609     } catch (...) {
59610       {
59611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59612       };
59613     }
59614   }
59615   jresult = (void *)result;
59616   return jresult;
59617 }
59618
59619
59620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
59621   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59622   float arg2 ;
59623
59624   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59625   arg2 = (float)jarg2;
59626   if (arg1) (arg1)->left = arg2;
59627 }
59628
59629
59630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
59631   float jresult ;
59632   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59633   float result;
59634
59635   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59636   result = (float) ((arg1)->left);
59637   jresult = result;
59638   return jresult;
59639 }
59640
59641
59642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
59643   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59644   float arg2 ;
59645
59646   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59647   arg2 = (float)jarg2;
59648   if (arg1) (arg1)->right = arg2;
59649 }
59650
59651
59652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
59653   float jresult ;
59654   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59655   float result;
59656
59657   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59658   result = (float) ((arg1)->right);
59659   jresult = result;
59660   return jresult;
59661 }
59662
59663
59664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
59665   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59666   float arg2 ;
59667
59668   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59669   arg2 = (float)jarg2;
59670   if (arg1) (arg1)->top = arg2;
59671 }
59672
59673
59674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
59675   float jresult ;
59676   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59677   float result;
59678
59679   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59680   result = (float) ((arg1)->top);
59681   jresult = result;
59682   return jresult;
59683 }
59684
59685
59686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
59687   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59688   float arg2 ;
59689
59690   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59691   arg2 = (float)jarg2;
59692   if (arg1) (arg1)->bottom = arg2;
59693 }
59694
59695
59696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
59697   float jresult ;
59698   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59699   float result;
59700
59701   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59702   result = (float) ((arg1)->bottom);
59703   jresult = result;
59704   return jresult;
59705 }
59706
59707
59708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
59709   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59710
59711   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59712   {
59713     try {
59714       delete arg1;
59715     } catch (std::out_of_range& e) {
59716       {
59717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59718       };
59719     } catch (std::exception& e) {
59720       {
59721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59722       };
59723     } catch (...) {
59724       {
59725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59726       };
59727     }
59728   }
59729 }
59730
59731
59732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
59733   void * jresult ;
59734   Dali::Toolkit::Alignment *result = 0 ;
59735
59736   {
59737     try {
59738       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
59739     } catch (std::out_of_range& e) {
59740       {
59741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59742       };
59743     } catch (std::exception& e) {
59744       {
59745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59746       };
59747     } catch (...) {
59748       {
59749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59750       };
59751     }
59752   }
59753   jresult = (void *)result;
59754   return jresult;
59755 }
59756
59757
59758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
59759   void * jresult ;
59760   Dali::Toolkit::Alignment::Type arg1 ;
59761   Dali::Toolkit::Alignment::Type arg2 ;
59762   Dali::Toolkit::Alignment result;
59763
59764   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59765   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59766   {
59767     try {
59768       result = Dali::Toolkit::Alignment::New(arg1,arg2);
59769     } catch (std::out_of_range& e) {
59770       {
59771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59772       };
59773     } catch (std::exception& e) {
59774       {
59775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59776       };
59777     } catch (...) {
59778       {
59779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59780       };
59781     }
59782   }
59783   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59784   return jresult;
59785 }
59786
59787
59788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
59789   void * jresult ;
59790   Dali::Toolkit::Alignment::Type arg1 ;
59791   Dali::Toolkit::Alignment result;
59792
59793   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59794   {
59795     try {
59796       result = Dali::Toolkit::Alignment::New(arg1);
59797     } catch (std::out_of_range& e) {
59798       {
59799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59800       };
59801     } catch (std::exception& e) {
59802       {
59803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59804       };
59805     } catch (...) {
59806       {
59807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59808       };
59809     }
59810   }
59811   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59812   return jresult;
59813 }
59814
59815
59816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
59817   void * jresult ;
59818   Dali::Toolkit::Alignment result;
59819
59820   {
59821     try {
59822       result = Dali::Toolkit::Alignment::New();
59823     } catch (std::out_of_range& e) {
59824       {
59825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59826       };
59827     } catch (std::exception& e) {
59828       {
59829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59830       };
59831     } catch (...) {
59832       {
59833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59834       };
59835     }
59836   }
59837   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59838   return jresult;
59839 }
59840
59841
59842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
59843   void * jresult ;
59844   Dali::Toolkit::Alignment *arg1 = 0 ;
59845   Dali::Toolkit::Alignment *result = 0 ;
59846
59847   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59848   if (!arg1) {
59849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59850     return 0;
59851   }
59852   {
59853     try {
59854       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
59855     } catch (std::out_of_range& e) {
59856       {
59857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59858       };
59859     } catch (std::exception& e) {
59860       {
59861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59862       };
59863     } catch (...) {
59864       {
59865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59866       };
59867     }
59868   }
59869   jresult = (void *)result;
59870   return jresult;
59871 }
59872
59873
59874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
59875   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59876
59877   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59878   {
59879     try {
59880       delete arg1;
59881     } catch (std::out_of_range& e) {
59882       {
59883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59884       };
59885     } catch (std::exception& e) {
59886       {
59887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59888       };
59889     } catch (...) {
59890       {
59891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59892       };
59893     }
59894   }
59895 }
59896
59897
59898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
59899   void * jresult ;
59900   Dali::BaseHandle arg1 ;
59901   Dali::BaseHandle *argp1 ;
59902   Dali::Toolkit::Alignment result;
59903
59904   argp1 = (Dali::BaseHandle *)jarg1;
59905   if (!argp1) {
59906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59907     return 0;
59908   }
59909   arg1 = *argp1;
59910   {
59911     try {
59912       result = Dali::Toolkit::Alignment::DownCast(arg1);
59913     } catch (std::out_of_range& e) {
59914       {
59915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59916       };
59917     } catch (std::exception& e) {
59918       {
59919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59920       };
59921     } catch (...) {
59922       {
59923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59924       };
59925     }
59926   }
59927   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59928   return jresult;
59929 }
59930
59931
59932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
59933   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59934   Dali::Toolkit::Alignment::Type arg2 ;
59935
59936   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59937   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59938   {
59939     try {
59940       (arg1)->SetAlignmentType(arg2);
59941     } catch (std::out_of_range& e) {
59942       {
59943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59944       };
59945     } catch (std::exception& e) {
59946       {
59947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59948       };
59949     } catch (...) {
59950       {
59951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59952       };
59953     }
59954   }
59955 }
59956
59957
59958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
59959   int jresult ;
59960   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59961   Dali::Toolkit::Alignment::Type result;
59962
59963   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59964   {
59965     try {
59966       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
59967     } catch (std::out_of_range& e) {
59968       {
59969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59970       };
59971     } catch (std::exception& e) {
59972       {
59973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59974       };
59975     } catch (...) {
59976       {
59977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59978       };
59979     }
59980   }
59981   jresult = (int)result;
59982   return jresult;
59983 }
59984
59985
59986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
59987   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59988   Dali::Toolkit::Alignment::Scaling arg2 ;
59989
59990   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59991   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
59992   {
59993     try {
59994       (arg1)->SetScaling(arg2);
59995     } catch (std::out_of_range& e) {
59996       {
59997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59998       };
59999     } catch (std::exception& e) {
60000       {
60001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60002       };
60003     } catch (...) {
60004       {
60005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60006       };
60007     }
60008   }
60009 }
60010
60011
60012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
60013   int jresult ;
60014   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
60015   Dali::Toolkit::Alignment::Scaling result;
60016
60017   arg1 = (Dali::Toolkit::Alignment *)jarg1;
60018   {
60019     try {
60020       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
60021     } catch (std::out_of_range& e) {
60022       {
60023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60024       };
60025     } catch (std::exception& e) {
60026       {
60027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60028       };
60029     } catch (...) {
60030       {
60031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60032       };
60033     }
60034   }
60035   jresult = (int)result;
60036   return jresult;
60037 }
60038
60039
60040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
60041   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
60042   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
60043
60044   arg1 = (Dali::Toolkit::Alignment *)jarg1;
60045   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
60046   if (!arg2) {
60047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
60048     return ;
60049   }
60050   {
60051     try {
60052       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
60053     } catch (std::out_of_range& e) {
60054       {
60055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60056       };
60057     } catch (std::exception& e) {
60058       {
60059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60060       };
60061     } catch (...) {
60062       {
60063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60064       };
60065     }
60066   }
60067 }
60068
60069
60070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
60071   void * jresult ;
60072   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
60073   Dali::Toolkit::Alignment::Padding *result = 0 ;
60074
60075   arg1 = (Dali::Toolkit::Alignment *)jarg1;
60076   {
60077     try {
60078       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
60079     } catch (std::out_of_range& e) {
60080       {
60081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60082       };
60083     } catch (std::exception& e) {
60084       {
60085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60086       };
60087     } catch (...) {
60088       {
60089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60090       };
60091     }
60092   }
60093   jresult = (void *)result;
60094   return jresult;
60095 }
60096
60097
60098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
60099   void * jresult ;
60100   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
60101   Dali::Toolkit::Alignment *arg2 = 0 ;
60102   Dali::Toolkit::Alignment *result = 0 ;
60103
60104   arg1 = (Dali::Toolkit::Alignment *)jarg1;
60105   arg2 = (Dali::Toolkit::Alignment *)jarg2;
60106   if (!arg2) {
60107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
60108     return 0;
60109   }
60110   {
60111     try {
60112       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
60113     } catch (std::out_of_range& e) {
60114       {
60115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60116       };
60117     } catch (std::exception& e) {
60118       {
60119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60120       };
60121     } catch (...) {
60122       {
60123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60124       };
60125     }
60126   }
60127   jresult = (void *)result;
60128   return jresult;
60129 }
60130
60131
60132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
60133   int jresult ;
60134   int result;
60135
60136   result = (int)Dali::Toolkit::Button::Property::DISABLED;
60137   jresult = (int)result;
60138   return jresult;
60139 }
60140
60141
60142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
60143   int jresult ;
60144   int result;
60145
60146   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
60147   jresult = (int)result;
60148   return jresult;
60149 }
60150
60151
60152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
60153   int jresult ;
60154   int result;
60155
60156   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
60157   jresult = (int)result;
60158   return jresult;
60159 }
60160
60161
60162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
60163   int jresult ;
60164   int result;
60165
60166   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
60167   jresult = (int)result;
60168   return jresult;
60169 }
60170
60171
60172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
60173   int jresult ;
60174   int result;
60175
60176   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
60177   jresult = (int)result;
60178   return jresult;
60179 }
60180
60181
60182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
60183   int jresult ;
60184   int result;
60185
60186   result = (int)Dali::Toolkit::Button::Property::SELECTED;
60187   jresult = (int)result;
60188   return jresult;
60189 }
60190
60191
60192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
60193   int jresult ;
60194   int result;
60195
60196   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
60197   jresult = (int)result;
60198   return jresult;
60199 }
60200
60201
60202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
60203   int jresult ;
60204   int result;
60205
60206   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
60207   jresult = (int)result;
60208   return jresult;
60209 }
60210
60211
60212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
60213   int jresult ;
60214   int result;
60215
60216   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
60217   jresult = (int)result;
60218   return jresult;
60219 }
60220
60221
60222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
60223   int jresult ;
60224   int result;
60225
60226   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
60227   jresult = (int)result;
60228   return jresult;
60229 }
60230
60231
60232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
60233   int jresult ;
60234   int result;
60235
60236   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
60237   jresult = (int)result;
60238   return jresult;
60239 }
60240
60241
60242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
60243   int jresult ;
60244   int result;
60245
60246   result = (int)Dali::Toolkit::Button::Property::LABEL;
60247   jresult = (int)result;
60248   return jresult;
60249 }
60250
60251
60252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
60253   int jresult ;
60254   int result;
60255
60256   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
60257   jresult = (int)result;
60258   return jresult;
60259 }
60260
60261
60262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
60263   void * jresult ;
60264   Dali::Toolkit::Button::Property *result = 0 ;
60265
60266   {
60267     try {
60268       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
60269     } catch (std::out_of_range& e) {
60270       {
60271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60272       };
60273     } catch (std::exception& e) {
60274       {
60275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60276       };
60277     } catch (...) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60280       };
60281     }
60282   }
60283   jresult = (void *)result;
60284   return jresult;
60285 }
60286
60287
60288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
60289   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
60290
60291   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
60292   {
60293     try {
60294       delete arg1;
60295     } catch (std::out_of_range& e) {
60296       {
60297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60298       };
60299     } catch (std::exception& e) {
60300       {
60301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60302       };
60303     } catch (...) {
60304       {
60305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60306       };
60307     }
60308   }
60309 }
60310
60311
60312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
60313   void * jresult ;
60314   Dali::Toolkit::Button *result = 0 ;
60315
60316   {
60317     try {
60318       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
60319     } catch (std::out_of_range& e) {
60320       {
60321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60322       };
60323     } catch (std::exception& e) {
60324       {
60325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60326       };
60327     } catch (...) {
60328       {
60329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60330       };
60331     }
60332   }
60333   jresult = (void *)result;
60334   return jresult;
60335 }
60336
60337
60338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
60339   void * jresult ;
60340   Dali::Toolkit::Button *arg1 = 0 ;
60341   Dali::Toolkit::Button *result = 0 ;
60342
60343   arg1 = (Dali::Toolkit::Button *)jarg1;
60344   if (!arg1) {
60345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60346     return 0;
60347   }
60348   {
60349     try {
60350       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
60351     } catch (std::out_of_range& e) {
60352       {
60353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60354       };
60355     } catch (std::exception& e) {
60356       {
60357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60358       };
60359     } catch (...) {
60360       {
60361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60362       };
60363     }
60364   }
60365   jresult = (void *)result;
60366   return jresult;
60367 }
60368
60369
60370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
60371   void * jresult ;
60372   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60373   Dali::Toolkit::Button *arg2 = 0 ;
60374   Dali::Toolkit::Button *result = 0 ;
60375
60376   arg1 = (Dali::Toolkit::Button *)jarg1;
60377   arg2 = (Dali::Toolkit::Button *)jarg2;
60378   if (!arg2) {
60379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60380     return 0;
60381   }
60382   {
60383     try {
60384       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
60385     } catch (std::out_of_range& e) {
60386       {
60387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60388       };
60389     } catch (std::exception& e) {
60390       {
60391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60392       };
60393     } catch (...) {
60394       {
60395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60396       };
60397     }
60398   }
60399   jresult = (void *)result;
60400   return jresult;
60401 }
60402
60403
60404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
60405   void * jresult ;
60406   Dali::BaseHandle arg1 ;
60407   Dali::BaseHandle *argp1 ;
60408   Dali::Toolkit::Button result;
60409
60410   argp1 = (Dali::BaseHandle *)jarg1;
60411   if (!argp1) {
60412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60413     return 0;
60414   }
60415   arg1 = *argp1;
60416   {
60417     try {
60418       result = Dali::Toolkit::Button::DownCast(arg1);
60419     } catch (std::out_of_range& e) {
60420       {
60421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60422       };
60423     } catch (std::exception& e) {
60424       {
60425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60426       };
60427     } catch (...) {
60428       {
60429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60430       };
60431     }
60432   }
60433   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
60434   return jresult;
60435 }
60436
60437
60438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
60439   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60440
60441   arg1 = (Dali::Toolkit::Button *)jarg1;
60442   {
60443     try {
60444       delete arg1;
60445     } catch (std::out_of_range& e) {
60446       {
60447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60448       };
60449     } catch (std::exception& e) {
60450       {
60451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60452       };
60453     } catch (...) {
60454       {
60455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60456       };
60457     }
60458   }
60459 }
60460
60461
60462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
60463   unsigned int jresult ;
60464   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60465   bool result;
60466
60467   arg1 = (Dali::Toolkit::Button *)jarg1;
60468   {
60469     try {
60470       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
60471     } catch (std::out_of_range& e) {
60472       {
60473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60474       };
60475     } catch (std::exception& e) {
60476       {
60477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60478       };
60479     } catch (...) {
60480       {
60481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60482       };
60483     }
60484   }
60485   jresult = result;
60486   return jresult;
60487 }
60488
60489
60490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
60491   unsigned int jresult ;
60492   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60493   bool result;
60494
60495   arg1 = (Dali::Toolkit::Button *)jarg1;
60496   {
60497     try {
60498       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
60499     } catch (std::out_of_range& e) {
60500       {
60501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60502       };
60503     } catch (std::exception& e) {
60504       {
60505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60506       };
60507     } catch (...) {
60508       {
60509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60510       };
60511     }
60512   }
60513   jresult = result;
60514   return jresult;
60515 }
60516
60517
60518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
60519   float jresult ;
60520   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60521   float result;
60522
60523   arg1 = (Dali::Toolkit::Button *)jarg1;
60524   {
60525     try {
60526       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
60527     } catch (std::out_of_range& e) {
60528       {
60529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60530       };
60531     } catch (std::exception& e) {
60532       {
60533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60534       };
60535     } catch (...) {
60536       {
60537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60538       };
60539     }
60540   }
60541   jresult = result;
60542   return jresult;
60543 }
60544
60545
60546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
60547   float jresult ;
60548   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60549   float result;
60550
60551   arg1 = (Dali::Toolkit::Button *)jarg1;
60552   {
60553     try {
60554       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
60555     } catch (std::out_of_range& e) {
60556       {
60557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60558       };
60559     } catch (std::exception& e) {
60560       {
60561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60562       };
60563     } catch (...) {
60564       {
60565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60566       };
60567     }
60568   }
60569   jresult = result;
60570   return jresult;
60571 }
60572
60573
60574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
60575   unsigned int jresult ;
60576   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60577   bool result;
60578
60579   arg1 = (Dali::Toolkit::Button *)jarg1;
60580   {
60581     try {
60582       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
60583     } catch (std::out_of_range& e) {
60584       {
60585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60586       };
60587     } catch (std::exception& e) {
60588       {
60589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60590       };
60591     } catch (...) {
60592       {
60593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60594       };
60595     }
60596   }
60597   jresult = result;
60598   return jresult;
60599 }
60600
60601
60602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
60603   unsigned int jresult ;
60604   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60605   bool result;
60606
60607   arg1 = (Dali::Toolkit::Button *)jarg1;
60608   {
60609     try {
60610       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
60611     } catch (std::out_of_range& e) {
60612       {
60613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60614       };
60615     } catch (std::exception& e) {
60616       {
60617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60618       };
60619     } catch (...) {
60620       {
60621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60622       };
60623     }
60624   }
60625   jresult = result;
60626   return jresult;
60627 }
60628
60629
60630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
60631   float jresult ;
60632   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60633   float result;
60634
60635   arg1 = (Dali::Toolkit::Button *)jarg1;
60636   {
60637     try {
60638       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
60639     } catch (std::out_of_range& e) {
60640       {
60641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60642       };
60643     } catch (std::exception& e) {
60644       {
60645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60646       };
60647     } catch (...) {
60648       {
60649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60650       };
60651     }
60652   }
60653   jresult = result;
60654   return jresult;
60655 }
60656
60657
60658 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
60659   char * jresult ;
60660   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60661   std::string result;
60662
60663   arg1 = (Dali::Toolkit::Button *)jarg1;
60664   {
60665     try {
60666       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
60667     } catch (std::out_of_range& e) {
60668       {
60669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60670       };
60671     } catch (std::exception& e) {
60672       {
60673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60674       };
60675     } catch (...) {
60676       {
60677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60678       };
60679     }
60680   }
60681   jresult = SWIG_csharp_string_callback((&result)->c_str());
60682   return jresult;
60683 }
60684
60685
60686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
60687   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60688   Dali::Actor arg2 ;
60689   Dali::Actor *argp2 ;
60690
60691   arg1 = (Dali::Toolkit::Button *)jarg1;
60692   argp2 = (Dali::Actor *)jarg2;
60693   if (!argp2) {
60694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60695     return ;
60696   }
60697   arg2 = *argp2;
60698   {
60699     try {
60700       (arg1)->SetLabel(arg2);
60701     } catch (std::out_of_range& e) {
60702       {
60703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60704       };
60705     } catch (std::exception& e) {
60706       {
60707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60708       };
60709     } catch (...) {
60710       {
60711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60712       };
60713     }
60714   }
60715 }
60716
60717
60718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
60719   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60720   Dali::Image arg2 ;
60721   Dali::Image *argp2 ;
60722
60723   arg1 = (Dali::Toolkit::Button *)jarg1;
60724   argp2 = (Dali::Image *)jarg2;
60725   if (!argp2) {
60726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60727     return ;
60728   }
60729   arg2 = *argp2;
60730   {
60731     try {
60732       (arg1)->SetButtonImage(arg2);
60733     } catch (std::out_of_range& e) {
60734       {
60735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60736       };
60737     } catch (std::exception& e) {
60738       {
60739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60740       };
60741     } catch (...) {
60742       {
60743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60744       };
60745     }
60746   }
60747 }
60748
60749
60750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
60751   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60752   Dali::Image arg2 ;
60753   Dali::Image *argp2 ;
60754
60755   arg1 = (Dali::Toolkit::Button *)jarg1;
60756   argp2 = (Dali::Image *)jarg2;
60757   if (!argp2) {
60758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60759     return ;
60760   }
60761   arg2 = *argp2;
60762   {
60763     try {
60764       (arg1)->SetSelectedImage(arg2);
60765     } catch (std::out_of_range& e) {
60766       {
60767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60768       };
60769     } catch (std::exception& e) {
60770       {
60771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60772       };
60773     } catch (...) {
60774       {
60775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60776       };
60777     }
60778   }
60779 }
60780
60781
60782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
60783   void * jresult ;
60784   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60785   Dali::Actor result;
60786
60787   arg1 = (Dali::Toolkit::Button *)jarg1;
60788   {
60789     try {
60790       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
60791     } catch (std::out_of_range& e) {
60792       {
60793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60794       };
60795     } catch (std::exception& e) {
60796       {
60797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60798       };
60799     } catch (...) {
60800       {
60801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60802       };
60803     }
60804   }
60805   jresult = new Dali::Actor((const Dali::Actor &)result);
60806   return jresult;
60807 }
60808
60809
60810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
60811   void * jresult ;
60812   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60813   Dali::Actor result;
60814
60815   arg1 = (Dali::Toolkit::Button *)jarg1;
60816   {
60817     try {
60818       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
60819     } catch (std::out_of_range& e) {
60820       {
60821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60822       };
60823     } catch (std::exception& e) {
60824       {
60825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60826       };
60827     } catch (...) {
60828       {
60829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60830       };
60831     }
60832   }
60833   jresult = new Dali::Actor((const Dali::Actor &)result);
60834   return jresult;
60835 }
60836
60837
60838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
60839   void * jresult ;
60840   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60841   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60842
60843   arg1 = (Dali::Toolkit::Button *)jarg1;
60844   {
60845     try {
60846       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
60847     } catch (std::out_of_range& e) {
60848       {
60849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60850       };
60851     } catch (std::exception& e) {
60852       {
60853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60854       };
60855     } catch (...) {
60856       {
60857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60858       };
60859     }
60860   }
60861   jresult = (void *)result;
60862   return jresult;
60863 }
60864
60865
60866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
60867   void * jresult ;
60868   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60869   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60870
60871   arg1 = (Dali::Toolkit::Button *)jarg1;
60872   {
60873     try {
60874       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
60875     } catch (std::out_of_range& e) {
60876       {
60877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60878       };
60879     } catch (std::exception& e) {
60880       {
60881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60882       };
60883     } catch (...) {
60884       {
60885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60886       };
60887     }
60888   }
60889   jresult = (void *)result;
60890   return jresult;
60891 }
60892
60893
60894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
60895   void * jresult ;
60896   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60897   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60898
60899   arg1 = (Dali::Toolkit::Button *)jarg1;
60900   {
60901     try {
60902       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
60903     } catch (std::out_of_range& e) {
60904       {
60905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60906       };
60907     } catch (std::exception& e) {
60908       {
60909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60910       };
60911     } catch (...) {
60912       {
60913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60914       };
60915     }
60916   }
60917   jresult = (void *)result;
60918   return jresult;
60919 }
60920
60921
60922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
60923   void * jresult ;
60924   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60925   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60926
60927   arg1 = (Dali::Toolkit::Button *)jarg1;
60928   {
60929     try {
60930       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
60931     } catch (std::out_of_range& e) {
60932       {
60933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60934       };
60935     } catch (std::exception& e) {
60936       {
60937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60938       };
60939     } catch (...) {
60940       {
60941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60942       };
60943     }
60944   }
60945   jresult = (void *)result;
60946   return jresult;
60947 }
60948
60949
60950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
60951   void * jresult ;
60952   Dali::Toolkit::CheckBoxButton *result = 0 ;
60953
60954   {
60955     try {
60956       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
60957     } catch (std::out_of_range& e) {
60958       {
60959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60960       };
60961     } catch (std::exception& e) {
60962       {
60963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60964       };
60965     } catch (...) {
60966       {
60967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60968       };
60969     }
60970   }
60971   jresult = (void *)result;
60972   return jresult;
60973 }
60974
60975
60976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
60977   void * jresult ;
60978   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
60979   Dali::Toolkit::CheckBoxButton *result = 0 ;
60980
60981   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60982   if (!arg1) {
60983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60984     return 0;
60985   }
60986   {
60987     try {
60988       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
60989     } catch (std::out_of_range& e) {
60990       {
60991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (std::exception& e) {
60994       {
60995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60996       };
60997     } catch (...) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61000       };
61001     }
61002   }
61003   jresult = (void *)result;
61004   return jresult;
61005 }
61006
61007
61008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
61009   void * jresult ;
61010   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
61011   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
61012   Dali::Toolkit::CheckBoxButton *result = 0 ;
61013
61014   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
61015   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
61016   if (!arg2) {
61017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
61018     return 0;
61019   }
61020   {
61021     try {
61022       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
61023     } catch (std::out_of_range& e) {
61024       {
61025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61026       };
61027     } catch (std::exception& e) {
61028       {
61029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61030       };
61031     } catch (...) {
61032       {
61033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61034       };
61035     }
61036   }
61037   jresult = (void *)result;
61038   return jresult;
61039 }
61040
61041
61042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
61043   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
61044
61045   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
61046   {
61047     try {
61048       delete arg1;
61049     } catch (std::out_of_range& e) {
61050       {
61051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61052       };
61053     } catch (std::exception& e) {
61054       {
61055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61056       };
61057     } catch (...) {
61058       {
61059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61060       };
61061     }
61062   }
61063 }
61064
61065
61066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
61067   void * jresult ;
61068   Dali::Toolkit::CheckBoxButton result;
61069
61070   {
61071     try {
61072       result = Dali::Toolkit::CheckBoxButton::New();
61073     } catch (std::out_of_range& e) {
61074       {
61075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61076       };
61077     } catch (std::exception& e) {
61078       {
61079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61080       };
61081     } catch (...) {
61082       {
61083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61084       };
61085     }
61086   }
61087   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
61088   return jresult;
61089 }
61090
61091
61092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
61093   void * jresult ;
61094   Dali::BaseHandle arg1 ;
61095   Dali::BaseHandle *argp1 ;
61096   Dali::Toolkit::CheckBoxButton result;
61097
61098   argp1 = (Dali::BaseHandle *)jarg1;
61099   if (!argp1) {
61100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61101     return 0;
61102   }
61103   arg1 = *argp1;
61104   {
61105     try {
61106       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
61107     } catch (std::out_of_range& e) {
61108       {
61109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61110       };
61111     } catch (std::exception& e) {
61112       {
61113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61114       };
61115     } catch (...) {
61116       {
61117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61118       };
61119     }
61120   }
61121   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
61122   return jresult;
61123 }
61124
61125
61126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
61127   int jresult ;
61128   int result;
61129
61130   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
61131   jresult = (int)result;
61132   return jresult;
61133 }
61134
61135
61136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
61137   int jresult ;
61138   int result;
61139
61140   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
61141   jresult = (int)result;
61142   return jresult;
61143 }
61144
61145
61146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
61147   int jresult ;
61148   int result;
61149
61150   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
61151   jresult = (int)result;
61152   return jresult;
61153 }
61154
61155
61156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
61157   int jresult ;
61158   int result;
61159
61160   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
61161   jresult = (int)result;
61162   return jresult;
61163 }
61164
61165
61166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
61167   int jresult ;
61168   int result;
61169
61170   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
61171   jresult = (int)result;
61172   return jresult;
61173 }
61174
61175
61176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
61177   void * jresult ;
61178   Dali::Toolkit::PushButton::Property *result = 0 ;
61179
61180   {
61181     try {
61182       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
61183     } catch (std::out_of_range& e) {
61184       {
61185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61186       };
61187     } catch (std::exception& e) {
61188       {
61189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61190       };
61191     } catch (...) {
61192       {
61193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61194       };
61195     }
61196   }
61197   jresult = (void *)result;
61198   return jresult;
61199 }
61200
61201
61202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
61203   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
61204
61205   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
61206   {
61207     try {
61208       delete arg1;
61209     } catch (std::out_of_range& e) {
61210       {
61211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61212       };
61213     } catch (std::exception& e) {
61214       {
61215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61216       };
61217     } catch (...) {
61218       {
61219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61220       };
61221     }
61222   }
61223 }
61224
61225
61226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
61227   void * jresult ;
61228   Dali::Toolkit::PushButton *result = 0 ;
61229
61230   {
61231     try {
61232       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
61233     } catch (std::out_of_range& e) {
61234       {
61235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61236       };
61237     } catch (std::exception& e) {
61238       {
61239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61240       };
61241     } catch (...) {
61242       {
61243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61244       };
61245     }
61246   }
61247   jresult = (void *)result;
61248   return jresult;
61249 }
61250
61251
61252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
61253   void * jresult ;
61254   Dali::Toolkit::PushButton *arg1 = 0 ;
61255   Dali::Toolkit::PushButton *result = 0 ;
61256
61257   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61258   if (!arg1) {
61259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
61260     return 0;
61261   }
61262   {
61263     try {
61264       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
61265     } catch (std::out_of_range& e) {
61266       {
61267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61268       };
61269     } catch (std::exception& e) {
61270       {
61271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61272       };
61273     } catch (...) {
61274       {
61275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61276       };
61277     }
61278   }
61279   jresult = (void *)result;
61280   return jresult;
61281 }
61282
61283
61284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
61285   void * jresult ;
61286   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61287   Dali::Toolkit::PushButton *arg2 = 0 ;
61288   Dali::Toolkit::PushButton *result = 0 ;
61289
61290   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61291   arg2 = (Dali::Toolkit::PushButton *)jarg2;
61292   if (!arg2) {
61293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
61294     return 0;
61295   }
61296   {
61297     try {
61298       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
61299     } catch (std::out_of_range& e) {
61300       {
61301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61302       };
61303     } catch (std::exception& e) {
61304       {
61305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61306       };
61307     } catch (...) {
61308       {
61309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61310       };
61311     }
61312   }
61313   jresult = (void *)result;
61314   return jresult;
61315 }
61316
61317
61318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
61319   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61320
61321   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61322   {
61323     try {
61324       delete arg1;
61325     } catch (std::out_of_range& e) {
61326       {
61327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61328       };
61329     } catch (std::exception& e) {
61330       {
61331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61332       };
61333     } catch (...) {
61334       {
61335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61336       };
61337     }
61338   }
61339 }
61340
61341
61342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
61343   void * jresult ;
61344   Dali::Toolkit::PushButton result;
61345
61346   {
61347     try {
61348       result = Dali::Toolkit::PushButton::New();
61349     } catch (std::out_of_range& e) {
61350       {
61351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61352       };
61353     } catch (std::exception& e) {
61354       {
61355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61356       };
61357     } catch (...) {
61358       {
61359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61360       };
61361     }
61362   }
61363   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61364   return jresult;
61365 }
61366
61367
61368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
61369   void * jresult ;
61370   Dali::BaseHandle arg1 ;
61371   Dali::BaseHandle *argp1 ;
61372   Dali::Toolkit::PushButton result;
61373
61374   argp1 = (Dali::BaseHandle *)jarg1;
61375   if (!argp1) {
61376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61377     return 0;
61378   }
61379   arg1 = *argp1;
61380   {
61381     try {
61382       result = Dali::Toolkit::PushButton::DownCast(arg1);
61383     } catch (std::out_of_range& e) {
61384       {
61385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61386       };
61387     } catch (std::exception& e) {
61388       {
61389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61390       };
61391     } catch (...) {
61392       {
61393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61394       };
61395     }
61396   }
61397   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61398   return jresult;
61399 }
61400
61401
61402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
61403   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61404   Dali::Image arg2 ;
61405   Dali::Image *argp2 ;
61406
61407   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61408   argp2 = (Dali::Image *)jarg2;
61409   if (!argp2) {
61410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61411     return ;
61412   }
61413   arg2 = *argp2;
61414   {
61415     try {
61416       (arg1)->SetButtonImage(arg2);
61417     } catch (std::out_of_range& e) {
61418       {
61419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61420       };
61421     } catch (std::exception& e) {
61422       {
61423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61424       };
61425     } catch (...) {
61426       {
61427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61428       };
61429     }
61430   }
61431 }
61432
61433
61434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
61435   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61436   Dali::Actor arg2 ;
61437   Dali::Actor *argp2 ;
61438
61439   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61440   argp2 = (Dali::Actor *)jarg2;
61441   if (!argp2) {
61442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61443     return ;
61444   }
61445   arg2 = *argp2;
61446   {
61447     try {
61448       (arg1)->SetButtonImage(arg2);
61449     } catch (std::out_of_range& e) {
61450       {
61451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61452       };
61453     } catch (std::exception& e) {
61454       {
61455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61456       };
61457     } catch (...) {
61458       {
61459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61460       };
61461     }
61462   }
61463 }
61464
61465
61466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
61467   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61468   Dali::Actor arg2 ;
61469   Dali::Actor *argp2 ;
61470
61471   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61472   argp2 = (Dali::Actor *)jarg2;
61473   if (!argp2) {
61474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61475     return ;
61476   }
61477   arg2 = *argp2;
61478   {
61479     try {
61480       (arg1)->SetBackgroundImage(arg2);
61481     } catch (std::out_of_range& e) {
61482       {
61483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61484       };
61485     } catch (std::exception& e) {
61486       {
61487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61488       };
61489     } catch (...) {
61490       {
61491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61492       };
61493     }
61494   }
61495 }
61496
61497
61498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
61499   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61500   Dali::Image arg2 ;
61501   Dali::Image *argp2 ;
61502
61503   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61504   argp2 = (Dali::Image *)jarg2;
61505   if (!argp2) {
61506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61507     return ;
61508   }
61509   arg2 = *argp2;
61510   {
61511     try {
61512       (arg1)->SetSelectedImage(arg2);
61513     } catch (std::out_of_range& e) {
61514       {
61515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61516       };
61517     } catch (std::exception& e) {
61518       {
61519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61520       };
61521     } catch (...) {
61522       {
61523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61524       };
61525     }
61526   }
61527 }
61528
61529
61530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
61531   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61532   Dali::Actor arg2 ;
61533   Dali::Actor *argp2 ;
61534
61535   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61536   argp2 = (Dali::Actor *)jarg2;
61537   if (!argp2) {
61538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61539     return ;
61540   }
61541   arg2 = *argp2;
61542   {
61543     try {
61544       (arg1)->SetSelectedImage(arg2);
61545     } catch (std::out_of_range& e) {
61546       {
61547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61548       };
61549     } catch (std::exception& e) {
61550       {
61551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61552       };
61553     } catch (...) {
61554       {
61555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61556       };
61557     }
61558   }
61559 }
61560
61561
61562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
61563   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61564   Dali::Actor arg2 ;
61565   Dali::Actor *argp2 ;
61566
61567   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61568   argp2 = (Dali::Actor *)jarg2;
61569   if (!argp2) {
61570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61571     return ;
61572   }
61573   arg2 = *argp2;
61574   {
61575     try {
61576       (arg1)->SetSelectedBackgroundImage(arg2);
61577     } catch (std::out_of_range& e) {
61578       {
61579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61580       };
61581     } catch (std::exception& e) {
61582       {
61583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61584       };
61585     } catch (...) {
61586       {
61587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61588       };
61589     }
61590   }
61591 }
61592
61593
61594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
61595   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61596   Dali::Actor arg2 ;
61597   Dali::Actor *argp2 ;
61598
61599   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61600   argp2 = (Dali::Actor *)jarg2;
61601   if (!argp2) {
61602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61603     return ;
61604   }
61605   arg2 = *argp2;
61606   {
61607     try {
61608       (arg1)->SetDisabledBackgroundImage(arg2);
61609     } catch (std::out_of_range& e) {
61610       {
61611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61612       };
61613     } catch (std::exception& e) {
61614       {
61615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61616       };
61617     } catch (...) {
61618       {
61619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61620       };
61621     }
61622   }
61623 }
61624
61625
61626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
61627   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61628   Dali::Actor arg2 ;
61629   Dali::Actor *argp2 ;
61630
61631   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61632   argp2 = (Dali::Actor *)jarg2;
61633   if (!argp2) {
61634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61635     return ;
61636   }
61637   arg2 = *argp2;
61638   {
61639     try {
61640       (arg1)->SetDisabledImage(arg2);
61641     } catch (std::out_of_range& e) {
61642       {
61643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61644       };
61645     } catch (std::exception& e) {
61646       {
61647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61648       };
61649     } catch (...) {
61650       {
61651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61652       };
61653     }
61654   }
61655 }
61656
61657
61658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
61659   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61660   Dali::Actor arg2 ;
61661   Dali::Actor *argp2 ;
61662
61663   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61664   argp2 = (Dali::Actor *)jarg2;
61665   if (!argp2) {
61666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61667     return ;
61668   }
61669   arg2 = *argp2;
61670   {
61671     try {
61672       (arg1)->SetDisabledSelectedImage(arg2);
61673     } catch (std::out_of_range& e) {
61674       {
61675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61676       };
61677     } catch (std::exception& e) {
61678       {
61679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61680       };
61681     } catch (...) {
61682       {
61683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61684       };
61685     }
61686   }
61687 }
61688
61689
61690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
61691   void * jresult ;
61692   Dali::Toolkit::RadioButton *result = 0 ;
61693
61694   {
61695     try {
61696       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
61697     } catch (std::out_of_range& e) {
61698       {
61699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61700       };
61701     } catch (std::exception& e) {
61702       {
61703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61704       };
61705     } catch (...) {
61706       {
61707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61708       };
61709     }
61710   }
61711   jresult = (void *)result;
61712   return jresult;
61713 }
61714
61715
61716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
61717   void * jresult ;
61718   Dali::Toolkit::RadioButton *arg1 = 0 ;
61719   Dali::Toolkit::RadioButton *result = 0 ;
61720
61721   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61722   if (!arg1) {
61723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61724     return 0;
61725   }
61726   {
61727     try {
61728       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
61729     } catch (std::out_of_range& e) {
61730       {
61731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61732       };
61733     } catch (std::exception& e) {
61734       {
61735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61736       };
61737     } catch (...) {
61738       {
61739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61740       };
61741     }
61742   }
61743   jresult = (void *)result;
61744   return jresult;
61745 }
61746
61747
61748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
61749   void * jresult ;
61750   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61751   Dali::Toolkit::RadioButton *arg2 = 0 ;
61752   Dali::Toolkit::RadioButton *result = 0 ;
61753
61754   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61755   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
61756   if (!arg2) {
61757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61758     return 0;
61759   }
61760   {
61761     try {
61762       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
61763     } catch (std::out_of_range& e) {
61764       {
61765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61766       };
61767     } catch (std::exception& e) {
61768       {
61769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61770       };
61771     } catch (...) {
61772       {
61773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61774       };
61775     }
61776   }
61777   jresult = (void *)result;
61778   return jresult;
61779 }
61780
61781
61782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
61783   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61784
61785   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61786   {
61787     try {
61788       delete arg1;
61789     } catch (std::out_of_range& e) {
61790       {
61791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61792       };
61793     } catch (std::exception& e) {
61794       {
61795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61796       };
61797     } catch (...) {
61798       {
61799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61800       };
61801     }
61802   }
61803 }
61804
61805
61806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
61807   void * jresult ;
61808   Dali::Toolkit::RadioButton result;
61809
61810   {
61811     try {
61812       result = Dali::Toolkit::RadioButton::New();
61813     } catch (std::out_of_range& e) {
61814       {
61815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61816       };
61817     } catch (std::exception& e) {
61818       {
61819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61820       };
61821     } catch (...) {
61822       {
61823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61824       };
61825     }
61826   }
61827   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61828   return jresult;
61829 }
61830
61831
61832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
61833   void * jresult ;
61834   std::string *arg1 = 0 ;
61835   Dali::Toolkit::RadioButton result;
61836
61837   if (!jarg1) {
61838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61839     return 0;
61840   }
61841   std::string arg1_str(jarg1);
61842   arg1 = &arg1_str;
61843   {
61844     try {
61845       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
61846     } catch (std::out_of_range& e) {
61847       {
61848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61849       };
61850     } catch (std::exception& e) {
61851       {
61852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61853       };
61854     } catch (...) {
61855       {
61856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61857       };
61858     }
61859   }
61860   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61861
61862   //argout typemap for const std::string&
61863
61864   return jresult;
61865 }
61866
61867
61868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
61869   void * jresult ;
61870   Dali::BaseHandle arg1 ;
61871   Dali::BaseHandle *argp1 ;
61872   Dali::Toolkit::RadioButton result;
61873
61874   argp1 = (Dali::BaseHandle *)jarg1;
61875   if (!argp1) {
61876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61877     return 0;
61878   }
61879   arg1 = *argp1;
61880   {
61881     try {
61882       result = Dali::Toolkit::RadioButton::DownCast(arg1);
61883     } catch (std::out_of_range& e) {
61884       {
61885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61886       };
61887     } catch (std::exception& e) {
61888       {
61889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61890       };
61891     } catch (...) {
61892       {
61893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61894       };
61895     }
61896   }
61897   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61898   return jresult;
61899 }
61900
61901
61902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
61903   int jresult ;
61904   int result;
61905
61906   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
61907   jresult = (int)result;
61908   return jresult;
61909 }
61910
61911
61912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
61913   int jresult ;
61914   int result;
61915
61916   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
61917   jresult = (int)result;
61918   return jresult;
61919 }
61920
61921
61922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
61923   int jresult ;
61924   int result;
61925
61926   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
61927   jresult = (int)result;
61928   return jresult;
61929 }
61930
61931
61932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
61933   int jresult ;
61934   int result;
61935
61936   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
61937   jresult = (int)result;
61938   return jresult;
61939 }
61940
61941
61942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
61943   int jresult ;
61944   int result;
61945
61946   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
61947   jresult = (int)result;
61948   return jresult;
61949 }
61950
61951
61952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
61953   int jresult ;
61954   int result;
61955
61956   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
61957   jresult = (int)result;
61958   return jresult;
61959 }
61960
61961
61962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
61963   void * jresult ;
61964   Dali::Toolkit::FlexContainer::Property *result = 0 ;
61965
61966   {
61967     try {
61968       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
61969     } catch (std::out_of_range& e) {
61970       {
61971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61972       };
61973     } catch (std::exception& e) {
61974       {
61975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61976       };
61977     } catch (...) {
61978       {
61979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61980       };
61981     }
61982   }
61983   jresult = (void *)result;
61984   return jresult;
61985 }
61986
61987
61988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
61989   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
61990
61991   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
61992   {
61993     try {
61994       delete arg1;
61995     } catch (std::out_of_range& e) {
61996       {
61997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61998       };
61999     } catch (std::exception& e) {
62000       {
62001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62002       };
62003     } catch (...) {
62004       {
62005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62006       };
62007     }
62008   }
62009 }
62010
62011
62012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
62013   int jresult ;
62014   int result;
62015
62016   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
62017   jresult = (int)result;
62018   return jresult;
62019 }
62020
62021
62022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
62023   int jresult ;
62024   int result;
62025
62026   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
62027   jresult = (int)result;
62028   return jresult;
62029 }
62030
62031
62032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
62033   int jresult ;
62034   int result;
62035
62036   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
62037   jresult = (int)result;
62038   return jresult;
62039 }
62040
62041
62042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
62043   void * jresult ;
62044   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
62045
62046   {
62047     try {
62048       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
62049     } catch (std::out_of_range& e) {
62050       {
62051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62052       };
62053     } catch (std::exception& e) {
62054       {
62055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62056       };
62057     } catch (...) {
62058       {
62059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62060       };
62061     }
62062   }
62063   jresult = (void *)result;
62064   return jresult;
62065 }
62066
62067
62068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
62069   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
62070
62071   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
62072   {
62073     try {
62074       delete arg1;
62075     } catch (std::out_of_range& e) {
62076       {
62077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62078       };
62079     } catch (std::exception& e) {
62080       {
62081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62082       };
62083     } catch (...) {
62084       {
62085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62086       };
62087     }
62088   }
62089 }
62090
62091
62092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
62093   void * jresult ;
62094   Dali::Toolkit::FlexContainer *result = 0 ;
62095
62096   {
62097     try {
62098       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
62099     } catch (std::out_of_range& e) {
62100       {
62101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62102       };
62103     } catch (std::exception& e) {
62104       {
62105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62106       };
62107     } catch (...) {
62108       {
62109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62110       };
62111     }
62112   }
62113   jresult = (void *)result;
62114   return jresult;
62115 }
62116
62117
62118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
62119   void * jresult ;
62120   Dali::Toolkit::FlexContainer *arg1 = 0 ;
62121   Dali::Toolkit::FlexContainer *result = 0 ;
62122
62123   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
62124   if (!arg1) {
62125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
62126     return 0;
62127   }
62128   {
62129     try {
62130       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
62131     } catch (std::out_of_range& e) {
62132       {
62133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62134       };
62135     } catch (std::exception& e) {
62136       {
62137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62138       };
62139     } catch (...) {
62140       {
62141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62142       };
62143     }
62144   }
62145   jresult = (void *)result;
62146   return jresult;
62147 }
62148
62149
62150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
62151   void * jresult ;
62152   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
62153   Dali::Toolkit::FlexContainer *arg2 = 0 ;
62154   Dali::Toolkit::FlexContainer *result = 0 ;
62155
62156   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
62157   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
62158   if (!arg2) {
62159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
62160     return 0;
62161   }
62162   {
62163     try {
62164       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
62165     } catch (std::out_of_range& e) {
62166       {
62167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62168       };
62169     } catch (std::exception& e) {
62170       {
62171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62172       };
62173     } catch (...) {
62174       {
62175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62176       };
62177     }
62178   }
62179   jresult = (void *)result;
62180   return jresult;
62181 }
62182
62183
62184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
62185   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
62186
62187   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
62188   {
62189     try {
62190       delete arg1;
62191     } catch (std::out_of_range& e) {
62192       {
62193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62194       };
62195     } catch (std::exception& e) {
62196       {
62197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62198       };
62199     } catch (...) {
62200       {
62201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62202       };
62203     }
62204   }
62205 }
62206
62207
62208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
62209   void * jresult ;
62210   Dali::Toolkit::FlexContainer result;
62211
62212   {
62213     try {
62214       result = Dali::Toolkit::FlexContainer::New();
62215     } catch (std::out_of_range& e) {
62216       {
62217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62218       };
62219     } catch (std::exception& e) {
62220       {
62221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62222       };
62223     } catch (...) {
62224       {
62225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62226       };
62227     }
62228   }
62229   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
62230   return jresult;
62231 }
62232
62233
62234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
62235   void * jresult ;
62236   Dali::BaseHandle arg1 ;
62237   Dali::BaseHandle *argp1 ;
62238   Dali::Toolkit::FlexContainer result;
62239
62240   argp1 = (Dali::BaseHandle *)jarg1;
62241   if (!argp1) {
62242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62243     return 0;
62244   }
62245   arg1 = *argp1;
62246   {
62247     try {
62248       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
62249     } catch (std::out_of_range& e) {
62250       {
62251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62252       };
62253     } catch (std::exception& e) {
62254       {
62255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62256       };
62257     } catch (...) {
62258       {
62259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62260       };
62261     }
62262   }
62263   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
62264   return jresult;
62265 }
62266
62267
62268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
62269   int jresult ;
62270   int result;
62271
62272   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
62273   jresult = (int)result;
62274   return jresult;
62275 }
62276
62277
62278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
62279   int jresult ;
62280   int result;
62281
62282   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
62283   jresult = (int)result;
62284   return jresult;
62285 }
62286
62287
62288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
62289   int jresult ;
62290   int result;
62291
62292   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
62293   jresult = (int)result;
62294   return jresult;
62295 }
62296
62297
62298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
62299   int jresult ;
62300   int result;
62301
62302   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
62303   jresult = (int)result;
62304   return jresult;
62305 }
62306
62307
62308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
62309   void * jresult ;
62310   Dali::Toolkit::ImageView::Property *result = 0 ;
62311
62312   {
62313     try {
62314       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
62315     } catch (std::out_of_range& e) {
62316       {
62317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62318       };
62319     } catch (std::exception& e) {
62320       {
62321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62322       };
62323     } catch (...) {
62324       {
62325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62326       };
62327     }
62328   }
62329   jresult = (void *)result;
62330   return jresult;
62331 }
62332
62333
62334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
62335   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
62336
62337   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
62338   {
62339     try {
62340       delete arg1;
62341     } catch (std::out_of_range& e) {
62342       {
62343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62344       };
62345     } catch (std::exception& e) {
62346       {
62347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62348       };
62349     } catch (...) {
62350       {
62351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62352       };
62353     }
62354   }
62355 }
62356
62357
62358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
62359   void * jresult ;
62360   Dali::Toolkit::ImageView *result = 0 ;
62361
62362   {
62363     try {
62364       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
62365     } catch (std::out_of_range& e) {
62366       {
62367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62368       };
62369     } catch (std::exception& e) {
62370       {
62371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62372       };
62373     } catch (...) {
62374       {
62375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62376       };
62377     }
62378   }
62379   jresult = (void *)result;
62380   return jresult;
62381 }
62382
62383
62384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
62385   void * jresult ;
62386   Dali::Toolkit::ImageView result;
62387
62388   {
62389     try {
62390       result = Dali::Toolkit::ImageView::New();
62391     } catch (std::out_of_range& e) {
62392       {
62393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62394       };
62395     } catch (std::exception& e) {
62396       {
62397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62398       };
62399     } catch (...) {
62400       {
62401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62402       };
62403     }
62404   }
62405   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62406   return jresult;
62407 }
62408
62409
62410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
62411   void * jresult ;
62412   Dali::Image arg1 ;
62413   Dali::Image *argp1 ;
62414   Dali::Toolkit::ImageView result;
62415
62416   argp1 = (Dali::Image *)jarg1;
62417   if (!argp1) {
62418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62419     return 0;
62420   }
62421   arg1 = *argp1;
62422   {
62423     try {
62424       result = Dali::Toolkit::ImageView::New(arg1);
62425     } catch (std::out_of_range& e) {
62426       {
62427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62428       };
62429     } catch (std::exception& e) {
62430       {
62431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62432       };
62433     } catch (...) {
62434       {
62435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62436       };
62437     }
62438   }
62439   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62440   return jresult;
62441 }
62442
62443
62444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
62445   void * jresult ;
62446   std::string *arg1 = 0 ;
62447   Dali::Toolkit::ImageView result;
62448
62449   if (!jarg1) {
62450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62451     return 0;
62452   }
62453   std::string arg1_str(jarg1);
62454   arg1 = &arg1_str;
62455   {
62456     try {
62457       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
62458     } catch (std::out_of_range& e) {
62459       {
62460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62461       };
62462     } catch (std::exception& e) {
62463       {
62464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62465       };
62466     } catch (...) {
62467       {
62468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62469       };
62470     }
62471   }
62472   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62473
62474   //argout typemap for const std::string&
62475
62476   return jresult;
62477 }
62478
62479
62480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
62481   void * jresult ;
62482   std::string *arg1 = 0 ;
62483   Dali::ImageDimensions arg2 ;
62484   Dali::ImageDimensions *argp2 ;
62485   Dali::Toolkit::ImageView result;
62486
62487   if (!jarg1) {
62488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62489     return 0;
62490   }
62491   std::string arg1_str(jarg1);
62492   arg1 = &arg1_str;
62493   argp2 = (Dali::ImageDimensions *)jarg2;
62494   if (!argp2) {
62495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62496     return 0;
62497   }
62498   arg2 = *argp2;
62499   {
62500     try {
62501       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
62502     } catch (std::out_of_range& e) {
62503       {
62504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62505       };
62506     } catch (std::exception& e) {
62507       {
62508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62509       };
62510     } catch (...) {
62511       {
62512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62513       };
62514     }
62515   }
62516   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62517
62518   //argout typemap for const std::string&
62519
62520   return jresult;
62521 }
62522
62523
62524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
62525   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62526
62527   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62528   {
62529     try {
62530       delete arg1;
62531     } catch (std::out_of_range& e) {
62532       {
62533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62534       };
62535     } catch (std::exception& e) {
62536       {
62537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62538       };
62539     } catch (...) {
62540       {
62541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62542       };
62543     }
62544   }
62545 }
62546
62547
62548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
62549   void * jresult ;
62550   Dali::Toolkit::ImageView *arg1 = 0 ;
62551   Dali::Toolkit::ImageView *result = 0 ;
62552
62553   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62554   if (!arg1) {
62555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62556     return 0;
62557   }
62558   {
62559     try {
62560       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
62561     } catch (std::out_of_range& e) {
62562       {
62563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62564       };
62565     } catch (std::exception& e) {
62566       {
62567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62568       };
62569     } catch (...) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62572       };
62573     }
62574   }
62575   jresult = (void *)result;
62576   return jresult;
62577 }
62578
62579
62580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
62581   void * jresult ;
62582   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62583   Dali::Toolkit::ImageView *arg2 = 0 ;
62584   Dali::Toolkit::ImageView *result = 0 ;
62585
62586   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62587   arg2 = (Dali::Toolkit::ImageView *)jarg2;
62588   if (!arg2) {
62589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62590     return 0;
62591   }
62592   {
62593     try {
62594       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
62595     } catch (std::out_of_range& e) {
62596       {
62597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62598       };
62599     } catch (std::exception& e) {
62600       {
62601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62602       };
62603     } catch (...) {
62604       {
62605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62606       };
62607     }
62608   }
62609   jresult = (void *)result;
62610   return jresult;
62611 }
62612
62613
62614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
62615   void * jresult ;
62616   Dali::BaseHandle arg1 ;
62617   Dali::BaseHandle *argp1 ;
62618   Dali::Toolkit::ImageView result;
62619
62620   argp1 = (Dali::BaseHandle *)jarg1;
62621   if (!argp1) {
62622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62623     return 0;
62624   }
62625   arg1 = *argp1;
62626   {
62627     try {
62628       result = Dali::Toolkit::ImageView::DownCast(arg1);
62629     } catch (std::out_of_range& e) {
62630       {
62631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62632       };
62633     } catch (std::exception& e) {
62634       {
62635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62636       };
62637     } catch (...) {
62638       {
62639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62640       };
62641     }
62642   }
62643   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62644   return jresult;
62645 }
62646
62647
62648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
62649   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62650   Dali::Image arg2 ;
62651   Dali::Image *argp2 ;
62652
62653   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62654   argp2 = (Dali::Image *)jarg2;
62655   if (!argp2) {
62656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62657     return ;
62658   }
62659   arg2 = *argp2;
62660   {
62661     try {
62662       (arg1)->SetImage(arg2);
62663     } catch (std::out_of_range& e) {
62664       {
62665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62666       };
62667     } catch (std::exception& e) {
62668       {
62669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62670       };
62671     } catch (...) {
62672       {
62673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62674       };
62675     }
62676   }
62677 }
62678
62679
62680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
62681   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62682   std::string *arg2 = 0 ;
62683
62684   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62685   if (!jarg2) {
62686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62687     return ;
62688   }
62689   std::string arg2_str(jarg2);
62690   arg2 = &arg2_str;
62691   {
62692     try {
62693       (arg1)->SetImage((std::string const &)*arg2);
62694     } catch (std::out_of_range& e) {
62695       {
62696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62697       };
62698     } catch (std::exception& e) {
62699       {
62700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62701       };
62702     } catch (...) {
62703       {
62704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62705       };
62706     }
62707   }
62708
62709   //argout typemap for const std::string&
62710
62711 }
62712
62713
62714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62715   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62716   std::string *arg2 = 0 ;
62717   Dali::ImageDimensions arg3 ;
62718   Dali::ImageDimensions *argp3 ;
62719
62720   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62721   if (!jarg2) {
62722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62723     return ;
62724   }
62725   std::string arg2_str(jarg2);
62726   arg2 = &arg2_str;
62727   argp3 = (Dali::ImageDimensions *)jarg3;
62728   if (!argp3) {
62729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62730     return ;
62731   }
62732   arg3 = *argp3;
62733   {
62734     try {
62735       (arg1)->SetImage((std::string const &)*arg2,arg3);
62736     } catch (std::out_of_range& e) {
62737       {
62738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62739       };
62740     } catch (std::exception& e) {
62741       {
62742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62743       };
62744     } catch (...) {
62745       {
62746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62747       };
62748     }
62749   }
62750
62751   //argout typemap for const std::string&
62752
62753 }
62754
62755
62756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
62757   void * jresult ;
62758   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62759   Dali::Image result;
62760
62761   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62762   {
62763     try {
62764       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
62765     } catch (std::out_of_range& e) {
62766       {
62767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62768       };
62769     } catch (std::exception& e) {
62770       {
62771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62772       };
62773     } catch (...) {
62774       {
62775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62776       };
62777     }
62778   }
62779   jresult = new Dali::Image((const Dali::Image &)result);
62780   return jresult;
62781 }
62782
62783
62784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
62785   int jresult ;
62786   int result;
62787
62788   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
62789   jresult = (int)result;
62790   return jresult;
62791 }
62792
62793
62794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
62795   int jresult ;
62796   int result;
62797
62798   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
62799   jresult = (int)result;
62800   return jresult;
62801 }
62802
62803
62804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
62805   int jresult ;
62806   int result;
62807
62808   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
62809   jresult = (int)result;
62810   return jresult;
62811 }
62812
62813
62814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
62815   int jresult ;
62816   int result;
62817
62818   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
62819   jresult = (int)result;
62820   return jresult;
62821 }
62822
62823
62824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
62825   int jresult ;
62826   int result;
62827
62828   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
62829   jresult = (int)result;
62830   return jresult;
62831 }
62832
62833
62834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
62835   int jresult ;
62836   int result;
62837
62838   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
62839   jresult = (int)result;
62840   return jresult;
62841 }
62842
62843
62844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
62845   int jresult ;
62846   int result;
62847
62848   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
62849   jresult = (int)result;
62850   return jresult;
62851 }
62852
62853
62854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
62855   int jresult ;
62856   int result;
62857
62858   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
62859   jresult = (int)result;
62860   return jresult;
62861 }
62862
62863
62864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
62865   void * jresult ;
62866   Dali::Toolkit::Model3dView::Property *result = 0 ;
62867
62868   {
62869     try {
62870       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
62871     } catch (std::out_of_range& e) {
62872       {
62873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62874       };
62875     } catch (std::exception& e) {
62876       {
62877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62878       };
62879     } catch (...) {
62880       {
62881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62882       };
62883     }
62884   }
62885   jresult = (void *)result;
62886   return jresult;
62887 }
62888
62889
62890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
62891   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
62892
62893   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
62894   {
62895     try {
62896       delete arg1;
62897     } catch (std::out_of_range& e) {
62898       {
62899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62900       };
62901     } catch (std::exception& e) {
62902       {
62903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62904       };
62905     } catch (...) {
62906       {
62907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62908       };
62909     }
62910   }
62911 }
62912
62913
62914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
62915   void * jresult ;
62916   Dali::Toolkit::Model3dView result;
62917
62918   {
62919     try {
62920       result = Dali::Toolkit::Model3dView::New();
62921     } catch (std::out_of_range& e) {
62922       {
62923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62924       };
62925     } catch (std::exception& e) {
62926       {
62927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62928       };
62929     } catch (...) {
62930       {
62931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62932       };
62933     }
62934   }
62935   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62936   return jresult;
62937 }
62938
62939
62940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
62941   void * jresult ;
62942   std::string *arg1 = 0 ;
62943   std::string *arg2 = 0 ;
62944   std::string *arg3 = 0 ;
62945   Dali::Toolkit::Model3dView result;
62946
62947   if (!jarg1) {
62948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62949     return 0;
62950   }
62951   std::string arg1_str(jarg1);
62952   arg1 = &arg1_str;
62953   if (!jarg2) {
62954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62955     return 0;
62956   }
62957   std::string arg2_str(jarg2);
62958   arg2 = &arg2_str;
62959   if (!jarg3) {
62960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62961     return 0;
62962   }
62963   std::string arg3_str(jarg3);
62964   arg3 = &arg3_str;
62965   {
62966     try {
62967       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
62968     } catch (std::out_of_range& e) {
62969       {
62970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62971       };
62972     } catch (std::exception& e) {
62973       {
62974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62975       };
62976     } catch (...) {
62977       {
62978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62979       };
62980     }
62981   }
62982   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62983
62984   //argout typemap for const std::string&
62985
62986
62987   //argout typemap for const std::string&
62988
62989
62990   //argout typemap for const std::string&
62991
62992   return jresult;
62993 }
62994
62995
62996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
62997   void * jresult ;
62998   Dali::Toolkit::Model3dView *result = 0 ;
62999
63000   {
63001     try {
63002       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
63003     } catch (std::out_of_range& e) {
63004       {
63005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63006       };
63007     } catch (std::exception& e) {
63008       {
63009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63010       };
63011     } catch (...) {
63012       {
63013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63014       };
63015     }
63016   }
63017   jresult = (void *)result;
63018   return jresult;
63019 }
63020
63021
63022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
63023   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
63024
63025   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
63026   {
63027     try {
63028       delete arg1;
63029     } catch (std::out_of_range& e) {
63030       {
63031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63032       };
63033     } catch (std::exception& e) {
63034       {
63035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63036       };
63037     } catch (...) {
63038       {
63039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63040       };
63041     }
63042   }
63043 }
63044
63045
63046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
63047   void * jresult ;
63048   Dali::Toolkit::Model3dView *arg1 = 0 ;
63049   Dali::Toolkit::Model3dView *result = 0 ;
63050
63051   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
63052   if (!arg1) {
63053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
63054     return 0;
63055   }
63056   {
63057     try {
63058       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
63059     } catch (std::out_of_range& e) {
63060       {
63061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63062       };
63063     } catch (std::exception& e) {
63064       {
63065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63066       };
63067     } catch (...) {
63068       {
63069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63070       };
63071     }
63072   }
63073   jresult = (void *)result;
63074   return jresult;
63075 }
63076
63077
63078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
63079   void * jresult ;
63080   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
63081   Dali::Toolkit::Model3dView *arg2 = 0 ;
63082   Dali::Toolkit::Model3dView *result = 0 ;
63083
63084   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
63085   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
63086   if (!arg2) {
63087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
63088     return 0;
63089   }
63090   {
63091     try {
63092       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
63093     } catch (std::out_of_range& e) {
63094       {
63095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63096       };
63097     } catch (std::exception& e) {
63098       {
63099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63100       };
63101     } catch (...) {
63102       {
63103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63104       };
63105     }
63106   }
63107   jresult = (void *)result;
63108   return jresult;
63109 }
63110
63111
63112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
63113   void * jresult ;
63114   Dali::BaseHandle arg1 ;
63115   Dali::BaseHandle *argp1 ;
63116   Dali::Toolkit::Model3dView result;
63117
63118   argp1 = (Dali::BaseHandle *)jarg1;
63119   if (!argp1) {
63120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63121     return 0;
63122   }
63123   arg1 = *argp1;
63124   {
63125     try {
63126       result = Dali::Toolkit::Model3dView::DownCast(arg1);
63127     } catch (std::out_of_range& e) {
63128       {
63129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63130       };
63131     } catch (std::exception& e) {
63132       {
63133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63134       };
63135     } catch (...) {
63136       {
63137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63138       };
63139     }
63140   }
63141   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
63142   return jresult;
63143 }
63144
63145
63146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
63147   int jresult ;
63148   int result;
63149
63150   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
63151   jresult = (int)result;
63152   return jresult;
63153 }
63154
63155
63156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
63157   int jresult ;
63158   int result;
63159
63160   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
63161   jresult = (int)result;
63162   return jresult;
63163 }
63164
63165
63166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
63167   int jresult ;
63168   int result;
63169
63170   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
63171   jresult = (int)result;
63172   return jresult;
63173 }
63174
63175
63176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
63177   int jresult ;
63178   int result;
63179
63180   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
63181   jresult = (int)result;
63182   return jresult;
63183 }
63184
63185
63186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
63187   int jresult ;
63188   int result;
63189
63190   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
63191   jresult = (int)result;
63192   return jresult;
63193 }
63194
63195
63196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
63197   int jresult ;
63198   int result;
63199
63200   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
63201   jresult = (int)result;
63202   return jresult;
63203 }
63204
63205
63206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
63207   int jresult ;
63208   int result;
63209
63210   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
63211   jresult = (int)result;
63212   return jresult;
63213 }
63214
63215
63216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
63217   int jresult ;
63218   int result;
63219
63220   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
63221   jresult = (int)result;
63222   return jresult;
63223 }
63224
63225
63226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
63227   int jresult ;
63228   int result;
63229
63230   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
63231   jresult = (int)result;
63232   return jresult;
63233 }
63234
63235
63236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
63237   void * jresult ;
63238   Dali::Toolkit::ScrollBar::Property *result = 0 ;
63239
63240   {
63241     try {
63242       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
63243     } catch (std::out_of_range& e) {
63244       {
63245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63246       };
63247     } catch (std::exception& e) {
63248       {
63249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63250       };
63251     } catch (...) {
63252       {
63253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63254       };
63255     }
63256   }
63257   jresult = (void *)result;
63258   return jresult;
63259 }
63260
63261
63262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
63263   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
63264
63265   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
63266   {
63267     try {
63268       delete arg1;
63269     } catch (std::out_of_range& e) {
63270       {
63271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63272       };
63273     } catch (std::exception& e) {
63274       {
63275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63276       };
63277     } catch (...) {
63278       {
63279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63280       };
63281     }
63282   }
63283 }
63284
63285
63286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
63287   void * jresult ;
63288   Dali::Toolkit::ScrollBar *result = 0 ;
63289
63290   {
63291     try {
63292       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
63293     } catch (std::out_of_range& e) {
63294       {
63295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63296       };
63297     } catch (std::exception& e) {
63298       {
63299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63300       };
63301     } catch (...) {
63302       {
63303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63304       };
63305     }
63306   }
63307   jresult = (void *)result;
63308   return jresult;
63309 }
63310
63311
63312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
63313   void * jresult ;
63314   Dali::Toolkit::ScrollBar *arg1 = 0 ;
63315   Dali::Toolkit::ScrollBar *result = 0 ;
63316
63317   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63318   if (!arg1) {
63319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
63320     return 0;
63321   }
63322   {
63323     try {
63324       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
63325     } catch (std::out_of_range& e) {
63326       {
63327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63328       };
63329     } catch (std::exception& e) {
63330       {
63331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63332       };
63333     } catch (...) {
63334       {
63335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63336       };
63337     }
63338   }
63339   jresult = (void *)result;
63340   return jresult;
63341 }
63342
63343
63344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
63345   void * jresult ;
63346   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63347   Dali::Toolkit::ScrollBar *arg2 = 0 ;
63348   Dali::Toolkit::ScrollBar *result = 0 ;
63349
63350   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63351   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
63352   if (!arg2) {
63353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
63354     return 0;
63355   }
63356   {
63357     try {
63358       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
63359     } catch (std::out_of_range& e) {
63360       {
63361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63362       };
63363     } catch (std::exception& e) {
63364       {
63365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63366       };
63367     } catch (...) {
63368       {
63369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63370       };
63371     }
63372   }
63373   jresult = (void *)result;
63374   return jresult;
63375 }
63376
63377
63378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
63379   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63380
63381   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63382   {
63383     try {
63384       delete arg1;
63385     } catch (std::out_of_range& e) {
63386       {
63387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63388       };
63389     } catch (std::exception& e) {
63390       {
63391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63392       };
63393     } catch (...) {
63394       {
63395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63396       };
63397     }
63398   }
63399 }
63400
63401
63402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
63403   void * jresult ;
63404   Dali::Toolkit::ScrollBar::Direction arg1 ;
63405   Dali::Toolkit::ScrollBar result;
63406
63407   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
63408   {
63409     try {
63410       result = Dali::Toolkit::ScrollBar::New(arg1);
63411     } catch (std::out_of_range& e) {
63412       {
63413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63414       };
63415     } catch (std::exception& e) {
63416       {
63417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63418       };
63419     } catch (...) {
63420       {
63421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63422       };
63423     }
63424   }
63425   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63426   return jresult;
63427 }
63428
63429
63430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
63431   void * jresult ;
63432   Dali::Toolkit::ScrollBar result;
63433
63434   {
63435     try {
63436       result = Dali::Toolkit::ScrollBar::New();
63437     } catch (std::out_of_range& e) {
63438       {
63439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63440       };
63441     } catch (std::exception& e) {
63442       {
63443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63444       };
63445     } catch (...) {
63446       {
63447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63448       };
63449     }
63450   }
63451   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63452   return jresult;
63453 }
63454
63455
63456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
63457   void * jresult ;
63458   Dali::BaseHandle arg1 ;
63459   Dali::BaseHandle *argp1 ;
63460   Dali::Toolkit::ScrollBar result;
63461
63462   argp1 = (Dali::BaseHandle *)jarg1;
63463   if (!argp1) {
63464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63465     return 0;
63466   }
63467   arg1 = *argp1;
63468   {
63469     try {
63470       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
63471     } catch (std::out_of_range& e) {
63472       {
63473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63474       };
63475     } catch (std::exception& e) {
63476       {
63477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63478       };
63479     } catch (...) {
63480       {
63481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63482       };
63483     }
63484   }
63485   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63486   return jresult;
63487 }
63488
63489
63490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
63491   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63492   Dali::Handle arg2 ;
63493   Dali::Property::Index arg3 ;
63494   Dali::Property::Index arg4 ;
63495   Dali::Property::Index arg5 ;
63496   Dali::Property::Index arg6 ;
63497   Dali::Handle *argp2 ;
63498
63499   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63500   argp2 = (Dali::Handle *)jarg2;
63501   if (!argp2) {
63502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
63503     return ;
63504   }
63505   arg2 = *argp2;
63506   arg3 = (Dali::Property::Index)jarg3;
63507   arg4 = (Dali::Property::Index)jarg4;
63508   arg5 = (Dali::Property::Index)jarg5;
63509   arg6 = (Dali::Property::Index)jarg6;
63510   {
63511     try {
63512       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
63513     } catch (std::out_of_range& e) {
63514       {
63515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63516       };
63517     } catch (std::exception& e) {
63518       {
63519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63520       };
63521     } catch (...) {
63522       {
63523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63524       };
63525     }
63526   }
63527 }
63528
63529
63530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
63531   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63532   Dali::Actor arg2 ;
63533   Dali::Actor *argp2 ;
63534
63535   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63536   argp2 = (Dali::Actor *)jarg2;
63537   if (!argp2) {
63538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63539     return ;
63540   }
63541   arg2 = *argp2;
63542   {
63543     try {
63544       (arg1)->SetScrollIndicator(arg2);
63545     } catch (std::out_of_range& e) {
63546       {
63547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63548       };
63549     } catch (std::exception& e) {
63550       {
63551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63552       };
63553     } catch (...) {
63554       {
63555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63556       };
63557     }
63558   }
63559 }
63560
63561
63562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
63563   void * jresult ;
63564   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63565   Dali::Actor result;
63566
63567   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63568   {
63569     try {
63570       result = (arg1)->GetScrollIndicator();
63571     } catch (std::out_of_range& e) {
63572       {
63573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63574       };
63575     } catch (std::exception& e) {
63576       {
63577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (...) {
63580       {
63581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63582       };
63583     }
63584   }
63585   jresult = new Dali::Actor((const Dali::Actor &)result);
63586   return jresult;
63587 }
63588
63589
63590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
63591   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63592   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
63593
63594   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63595   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
63596   if (!arg2) {
63597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
63598     return ;
63599   }
63600   {
63601     try {
63602       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
63603     } catch (std::out_of_range& e) {
63604       {
63605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63606       };
63607     } catch (std::exception& e) {
63608       {
63609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63610       };
63611     } catch (...) {
63612       {
63613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63614       };
63615     }
63616   }
63617 }
63618
63619
63620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
63621   void * jresult ;
63622   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63623   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
63624
63625   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63626   {
63627     try {
63628       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
63629     } catch (std::out_of_range& e) {
63630       {
63631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63632       };
63633     } catch (std::exception& e) {
63634       {
63635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63636       };
63637     } catch (...) {
63638       {
63639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63640       };
63641     }
63642   }
63643   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
63644   return jresult;
63645 }
63646
63647
63648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
63649   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63650   Dali::Toolkit::ScrollBar::Direction arg2 ;
63651
63652   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63653   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
63654   {
63655     try {
63656       (arg1)->SetScrollDirection(arg2);
63657     } catch (std::out_of_range& e) {
63658       {
63659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63660       };
63661     } catch (std::exception& e) {
63662       {
63663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63664       };
63665     } catch (...) {
63666       {
63667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63668       };
63669     }
63670   }
63671 }
63672
63673
63674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
63675   int jresult ;
63676   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63677   Dali::Toolkit::ScrollBar::Direction result;
63678
63679   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63680   {
63681     try {
63682       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
63683     } catch (std::out_of_range& e) {
63684       {
63685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63686       };
63687     } catch (std::exception& e) {
63688       {
63689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63690       };
63691     } catch (...) {
63692       {
63693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63694       };
63695     }
63696   }
63697   jresult = (int)result;
63698   return jresult;
63699 }
63700
63701
63702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
63703   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63704   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
63705
63706   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63707   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
63708   {
63709     try {
63710       (arg1)->SetIndicatorHeightPolicy(arg2);
63711     } catch (std::out_of_range& e) {
63712       {
63713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63714       };
63715     } catch (std::exception& e) {
63716       {
63717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63718       };
63719     } catch (...) {
63720       {
63721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63722       };
63723     }
63724   }
63725 }
63726
63727
63728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
63729   int jresult ;
63730   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63731   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
63732
63733   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63734   {
63735     try {
63736       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
63737     } catch (std::out_of_range& e) {
63738       {
63739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63740       };
63741     } catch (std::exception& e) {
63742       {
63743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63744       };
63745     } catch (...) {
63746       {
63747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63748       };
63749     }
63750   }
63751   jresult = (int)result;
63752   return jresult;
63753 }
63754
63755
63756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
63757   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63758   float arg2 ;
63759
63760   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63761   arg2 = (float)jarg2;
63762   {
63763     try {
63764       (arg1)->SetIndicatorFixedHeight(arg2);
63765     } catch (std::out_of_range& e) {
63766       {
63767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63768       };
63769     } catch (std::exception& e) {
63770       {
63771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63772       };
63773     } catch (...) {
63774       {
63775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63776       };
63777     }
63778   }
63779 }
63780
63781
63782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
63783   float jresult ;
63784   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63785   float result;
63786
63787   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63788   {
63789     try {
63790       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
63791     } catch (std::out_of_range& e) {
63792       {
63793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63794       };
63795     } catch (std::exception& e) {
63796       {
63797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63798       };
63799     } catch (...) {
63800       {
63801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63802       };
63803     }
63804   }
63805   jresult = result;
63806   return jresult;
63807 }
63808
63809
63810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
63811   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63812   float arg2 ;
63813
63814   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63815   arg2 = (float)jarg2;
63816   {
63817     try {
63818       (arg1)->SetIndicatorShowDuration(arg2);
63819     } catch (std::out_of_range& e) {
63820       {
63821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63822       };
63823     } catch (std::exception& e) {
63824       {
63825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63826       };
63827     } catch (...) {
63828       {
63829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63830       };
63831     }
63832   }
63833 }
63834
63835
63836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
63837   float jresult ;
63838   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63839   float result;
63840
63841   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63842   {
63843     try {
63844       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
63845     } catch (std::out_of_range& e) {
63846       {
63847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63848       };
63849     } catch (std::exception& e) {
63850       {
63851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63852       };
63853     } catch (...) {
63854       {
63855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63856       };
63857     }
63858   }
63859   jresult = result;
63860   return jresult;
63861 }
63862
63863
63864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
63865   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63866   float arg2 ;
63867
63868   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63869   arg2 = (float)jarg2;
63870   {
63871     try {
63872       (arg1)->SetIndicatorHideDuration(arg2);
63873     } catch (std::out_of_range& e) {
63874       {
63875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63876       };
63877     } catch (std::exception& e) {
63878       {
63879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63880       };
63881     } catch (...) {
63882       {
63883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63884       };
63885     }
63886   }
63887 }
63888
63889
63890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
63891   float jresult ;
63892   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63893   float result;
63894
63895   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63896   {
63897     try {
63898       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
63899     } catch (std::out_of_range& e) {
63900       {
63901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63902       };
63903     } catch (std::exception& e) {
63904       {
63905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63906       };
63907     } catch (...) {
63908       {
63909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63910       };
63911     }
63912   }
63913   jresult = result;
63914   return jresult;
63915 }
63916
63917
63918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
63919   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63920
63921   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63922   {
63923     try {
63924       (arg1)->ShowIndicator();
63925     } catch (std::out_of_range& e) {
63926       {
63927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63928       };
63929     } catch (std::exception& e) {
63930       {
63931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63932       };
63933     } catch (...) {
63934       {
63935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63936       };
63937     }
63938   }
63939 }
63940
63941
63942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
63943   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63944
63945   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63946   {
63947     try {
63948       (arg1)->HideIndicator();
63949     } catch (std::out_of_range& e) {
63950       {
63951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63952       };
63953     } catch (std::exception& e) {
63954       {
63955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63956       };
63957     } catch (...) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63960       };
63961     }
63962   }
63963 }
63964
63965
63966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
63967   void * jresult ;
63968   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63969   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
63970
63971   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63972   {
63973     try {
63974       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
63975     } catch (std::out_of_range& e) {
63976       {
63977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63978       };
63979     } catch (std::exception& e) {
63980       {
63981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63982       };
63983     } catch (...) {
63984       {
63985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63986       };
63987     }
63988   }
63989   jresult = (void *)result;
63990   return jresult;
63991 }
63992
63993
63994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
63995   void * jresult ;
63996   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63997   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
63998
63999   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
64000   {
64001     try {
64002       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
64003     } catch (std::out_of_range& e) {
64004       {
64005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64006       };
64007     } catch (std::exception& e) {
64008       {
64009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64010       };
64011     } catch (...) {
64012       {
64013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64014       };
64015     }
64016   }
64017   jresult = (void *)result;
64018   return jresult;
64019 }
64020
64021
64022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
64023   int jresult ;
64024   int result;
64025
64026   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
64027   jresult = (int)result;
64028   return jresult;
64029 }
64030
64031
64032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
64033   int jresult ;
64034   int result;
64035
64036   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
64037   jresult = (int)result;
64038   return jresult;
64039 }
64040
64041
64042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
64043   int jresult ;
64044   int result;
64045
64046   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
64047   jresult = (int)result;
64048   return jresult;
64049 }
64050
64051
64052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
64053   int jresult ;
64054   int result;
64055
64056   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
64057   jresult = (int)result;
64058   return jresult;
64059 }
64060
64061
64062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
64063   int jresult ;
64064   int result;
64065
64066   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
64067   jresult = (int)result;
64068   return jresult;
64069 }
64070
64071
64072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
64073   int jresult ;
64074   int result;
64075
64076   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
64077   jresult = (int)result;
64078   return jresult;
64079 }
64080
64081
64082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
64083   int jresult ;
64084   int result;
64085
64086   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
64087   jresult = (int)result;
64088   return jresult;
64089 }
64090
64091
64092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
64093   int jresult ;
64094   int result;
64095
64096   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
64097   jresult = (int)result;
64098   return jresult;
64099 }
64100
64101
64102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
64103   int jresult ;
64104   int result;
64105
64106   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
64107   jresult = (int)result;
64108   return jresult;
64109 }
64110
64111
64112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
64113   int jresult ;
64114   int result;
64115
64116   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
64117   jresult = (int)result;
64118   return jresult;
64119 }
64120
64121
64122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
64123   int jresult ;
64124   int result;
64125
64126   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
64127   jresult = (int)result;
64128   return jresult;
64129 }
64130
64131
64132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
64133   int jresult ;
64134   int result;
64135
64136   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
64137   jresult = (int)result;
64138   return jresult;
64139 }
64140
64141
64142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
64143   int jresult ;
64144   int result;
64145
64146   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
64147   jresult = (int)result;
64148   return jresult;
64149 }
64150
64151
64152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
64153   int jresult ;
64154   int result;
64155
64156   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
64157   jresult = (int)result;
64158   return jresult;
64159 }
64160
64161
64162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
64163   void * jresult ;
64164   Dali::Toolkit::Scrollable::Property *result = 0 ;
64165
64166   {
64167     try {
64168       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
64169     } catch (std::out_of_range& e) {
64170       {
64171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64172       };
64173     } catch (std::exception& e) {
64174       {
64175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64176       };
64177     } catch (...) {
64178       {
64179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64180       };
64181     }
64182   }
64183   jresult = (void *)result;
64184   return jresult;
64185 }
64186
64187
64188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
64189   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
64190
64191   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
64192   {
64193     try {
64194       delete arg1;
64195     } catch (std::out_of_range& e) {
64196       {
64197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64198       };
64199     } catch (std::exception& e) {
64200       {
64201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64202       };
64203     } catch (...) {
64204       {
64205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64206       };
64207     }
64208   }
64209 }
64210
64211
64212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
64213   void * jresult ;
64214   Dali::Toolkit::Scrollable *result = 0 ;
64215
64216   {
64217     try {
64218       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
64219     } catch (std::out_of_range& e) {
64220       {
64221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64222       };
64223     } catch (std::exception& e) {
64224       {
64225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64226       };
64227     } catch (...) {
64228       {
64229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64230       };
64231     }
64232   }
64233   jresult = (void *)result;
64234   return jresult;
64235 }
64236
64237
64238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
64239   void * jresult ;
64240   Dali::Toolkit::Scrollable *arg1 = 0 ;
64241   Dali::Toolkit::Scrollable *result = 0 ;
64242
64243   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64244   if (!arg1) {
64245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
64246     return 0;
64247   }
64248   {
64249     try {
64250       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
64251     } catch (std::out_of_range& e) {
64252       {
64253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64254       };
64255     } catch (std::exception& e) {
64256       {
64257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64258       };
64259     } catch (...) {
64260       {
64261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64262       };
64263     }
64264   }
64265   jresult = (void *)result;
64266   return jresult;
64267 }
64268
64269
64270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
64271   void * jresult ;
64272   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64273   Dali::Toolkit::Scrollable *arg2 = 0 ;
64274   Dali::Toolkit::Scrollable *result = 0 ;
64275
64276   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64277   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
64278   if (!arg2) {
64279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
64280     return 0;
64281   }
64282   {
64283     try {
64284       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
64285     } catch (std::out_of_range& e) {
64286       {
64287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64288       };
64289     } catch (std::exception& e) {
64290       {
64291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64292       };
64293     } catch (...) {
64294       {
64295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64296       };
64297     }
64298   }
64299   jresult = (void *)result;
64300   return jresult;
64301 }
64302
64303
64304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
64305   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64306
64307   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64308   {
64309     try {
64310       delete arg1;
64311     } catch (std::out_of_range& e) {
64312       {
64313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64314       };
64315     } catch (std::exception& e) {
64316       {
64317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64318       };
64319     } catch (...) {
64320       {
64321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64322       };
64323     }
64324   }
64325 }
64326
64327
64328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
64329   void * jresult ;
64330   Dali::BaseHandle arg1 ;
64331   Dali::BaseHandle *argp1 ;
64332   Dali::Toolkit::Scrollable result;
64333
64334   argp1 = (Dali::BaseHandle *)jarg1;
64335   if (!argp1) {
64336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64337     return 0;
64338   }
64339   arg1 = *argp1;
64340   {
64341     try {
64342       result = Dali::Toolkit::Scrollable::DownCast(arg1);
64343     } catch (std::out_of_range& e) {
64344       {
64345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64346       };
64347     } catch (std::exception& e) {
64348       {
64349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64350       };
64351     } catch (...) {
64352       {
64353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64354       };
64355     }
64356   }
64357   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
64358   return jresult;
64359 }
64360
64361
64362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
64363   unsigned int jresult ;
64364   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64365   bool result;
64366
64367   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64368   {
64369     try {
64370       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
64371     } catch (std::out_of_range& e) {
64372       {
64373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64374       };
64375     } catch (std::exception& e) {
64376       {
64377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64378       };
64379     } catch (...) {
64380       {
64381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64382       };
64383     }
64384   }
64385   jresult = result;
64386   return jresult;
64387 }
64388
64389
64390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
64391   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64392   bool arg2 ;
64393
64394   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64395   arg2 = jarg2 ? true : false;
64396   {
64397     try {
64398       (arg1)->SetOvershootEnabled(arg2);
64399     } catch (std::out_of_range& e) {
64400       {
64401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64402       };
64403     } catch (std::exception& e) {
64404       {
64405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64406       };
64407     } catch (...) {
64408       {
64409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64410       };
64411     }
64412   }
64413 }
64414
64415
64416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
64417   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64418   Dali::Vector4 *arg2 = 0 ;
64419
64420   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64421   arg2 = (Dali::Vector4 *)jarg2;
64422   if (!arg2) {
64423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
64424     return ;
64425   }
64426   {
64427     try {
64428       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
64429     } catch (std::out_of_range& e) {
64430       {
64431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64432       };
64433     } catch (std::exception& e) {
64434       {
64435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64436       };
64437     } catch (...) {
64438       {
64439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64440       };
64441     }
64442   }
64443 }
64444
64445
64446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
64447   void * jresult ;
64448   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64449   Dali::Vector4 result;
64450
64451   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64452   {
64453     try {
64454       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
64455     } catch (std::out_of_range& e) {
64456       {
64457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64458       };
64459     } catch (std::exception& e) {
64460       {
64461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64462       };
64463     } catch (...) {
64464       {
64465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64466       };
64467     }
64468   }
64469   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64470   return jresult;
64471 }
64472
64473
64474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
64475   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64476   float arg2 ;
64477
64478   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64479   arg2 = (float)jarg2;
64480   {
64481     try {
64482       (arg1)->SetOvershootAnimationSpeed(arg2);
64483     } catch (std::out_of_range& e) {
64484       {
64485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64486       };
64487     } catch (std::exception& e) {
64488       {
64489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64490       };
64491     } catch (...) {
64492       {
64493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64494       };
64495     }
64496   }
64497 }
64498
64499
64500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
64501   float jresult ;
64502   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64503   float result;
64504
64505   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64506   {
64507     try {
64508       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
64509     } catch (std::out_of_range& e) {
64510       {
64511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64512       };
64513     } catch (std::exception& e) {
64514       {
64515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64516       };
64517     } catch (...) {
64518       {
64519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64520       };
64521     }
64522   }
64523   jresult = result;
64524   return jresult;
64525 }
64526
64527
64528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
64529   void * jresult ;
64530   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64531   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
64532
64533   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64534   {
64535     try {
64536       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
64537     } catch (std::out_of_range& e) {
64538       {
64539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64540       };
64541     } catch (std::exception& e) {
64542       {
64543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64544       };
64545     } catch (...) {
64546       {
64547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64548       };
64549     }
64550   }
64551   jresult = (void *)result;
64552   return jresult;
64553 }
64554
64555
64556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
64557   void * jresult ;
64558   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64559   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
64560
64561   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64562   {
64563     try {
64564       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
64565     } catch (std::out_of_range& e) {
64566       {
64567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64568       };
64569     } catch (std::exception& e) {
64570       {
64571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64572       };
64573     } catch (...) {
64574       {
64575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64576       };
64577     }
64578   }
64579   jresult = (void *)result;
64580   return jresult;
64581 }
64582
64583
64584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
64585   void * jresult ;
64586   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64587   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
64588
64589   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64590   {
64591     try {
64592       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
64593     } catch (std::out_of_range& e) {
64594       {
64595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64596       };
64597     } catch (std::exception& e) {
64598       {
64599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64600       };
64601     } catch (...) {
64602       {
64603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64604       };
64605     }
64606   }
64607   jresult = (void *)result;
64608   return jresult;
64609 }
64610
64611
64612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
64613   unsigned int jresult ;
64614   Dali::Toolkit::ControlOrientation::Type arg1 ;
64615   bool result;
64616
64617   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64618   {
64619     try {
64620       result = (bool)Dali::Toolkit::IsVertical(arg1);
64621     } catch (std::out_of_range& e) {
64622       {
64623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64624       };
64625     } catch (std::exception& e) {
64626       {
64627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64628       };
64629     } catch (...) {
64630       {
64631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64632       };
64633     }
64634   }
64635   jresult = result;
64636   return jresult;
64637 }
64638
64639
64640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
64641   unsigned int jresult ;
64642   Dali::Toolkit::ControlOrientation::Type arg1 ;
64643   bool result;
64644
64645   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64646   {
64647     try {
64648       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
64649     } catch (std::out_of_range& e) {
64650       {
64651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64652       };
64653     } catch (std::exception& e) {
64654       {
64655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64656       };
64657     } catch (...) {
64658       {
64659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64660       };
64661     }
64662   }
64663   jresult = result;
64664   return jresult;
64665 }
64666
64667
64668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
64669   void * jresult ;
64670   unsigned int arg1 ;
64671   unsigned int arg2 ;
64672   Dali::Toolkit::ItemRange *result = 0 ;
64673
64674   arg1 = (unsigned int)jarg1;
64675   arg2 = (unsigned int)jarg2;
64676   {
64677     try {
64678       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
64679     } catch (std::out_of_range& e) {
64680       {
64681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64682       };
64683     } catch (std::exception& e) {
64684       {
64685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64686       };
64687     } catch (...) {
64688       {
64689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64690       };
64691     }
64692   }
64693   jresult = (void *)result;
64694   return jresult;
64695 }
64696
64697
64698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
64699   void * jresult ;
64700   Dali::Toolkit::ItemRange *arg1 = 0 ;
64701   Dali::Toolkit::ItemRange *result = 0 ;
64702
64703   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64704   if (!arg1) {
64705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64706     return 0;
64707   }
64708   {
64709     try {
64710       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
64711     } catch (std::out_of_range& e) {
64712       {
64713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64714       };
64715     } catch (std::exception& e) {
64716       {
64717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64718       };
64719     } catch (...) {
64720       {
64721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64722       };
64723     }
64724   }
64725   jresult = (void *)result;
64726   return jresult;
64727 }
64728
64729
64730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
64731   void * jresult ;
64732   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64733   Dali::Toolkit::ItemRange *arg2 = 0 ;
64734   Dali::Toolkit::ItemRange *result = 0 ;
64735
64736   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64737   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64738   if (!arg2) {
64739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64740     return 0;
64741   }
64742   {
64743     try {
64744       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
64745     } catch (std::out_of_range& e) {
64746       {
64747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64748       };
64749     } catch (std::exception& e) {
64750       {
64751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64752       };
64753     } catch (...) {
64754       {
64755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64756       };
64757     }
64758   }
64759   jresult = (void *)result;
64760   return jresult;
64761 }
64762
64763
64764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
64765   unsigned int jresult ;
64766   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64767   unsigned int arg2 ;
64768   bool result;
64769
64770   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64771   arg2 = (unsigned int)jarg2;
64772   {
64773     try {
64774       result = (bool)(arg1)->Within(arg2);
64775     } catch (std::out_of_range& e) {
64776       {
64777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64778       };
64779     } catch (std::exception& e) {
64780       {
64781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64782       };
64783     } catch (...) {
64784       {
64785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64786       };
64787     }
64788   }
64789   jresult = result;
64790   return jresult;
64791 }
64792
64793
64794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
64795   void * jresult ;
64796   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64797   Dali::Toolkit::ItemRange *arg2 = 0 ;
64798   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64799
64800   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64801   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64802   if (!arg2) {
64803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64804     return 0;
64805   }
64806   {
64807     try {
64808       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
64809     } catch (std::out_of_range& e) {
64810       {
64811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64812       };
64813     } catch (std::exception& e) {
64814       {
64815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64816       };
64817     } catch (...) {
64818       {
64819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64820       };
64821     }
64822   }
64823   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64824   return jresult;
64825 }
64826
64827
64828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
64829   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64830   unsigned int arg2 ;
64831
64832   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64833   arg2 = (unsigned int)jarg2;
64834   if (arg1) (arg1)->begin = arg2;
64835 }
64836
64837
64838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
64839   unsigned int jresult ;
64840   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64841   unsigned int result;
64842
64843   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64844   result = (unsigned int) ((arg1)->begin);
64845   jresult = result;
64846   return jresult;
64847 }
64848
64849
64850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
64851   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64852   unsigned int arg2 ;
64853
64854   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64855   arg2 = (unsigned int)jarg2;
64856   if (arg1) (arg1)->end = arg2;
64857 }
64858
64859
64860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
64861   unsigned int jresult ;
64862   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64863   unsigned int result;
64864
64865   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64866   result = (unsigned int) ((arg1)->end);
64867   jresult = result;
64868   return jresult;
64869 }
64870
64871
64872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
64873   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64874
64875   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64876   {
64877     try {
64878       delete arg1;
64879     } catch (std::out_of_range& e) {
64880       {
64881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64882       };
64883     } catch (std::exception& e) {
64884       {
64885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64886       };
64887     } catch (...) {
64888       {
64889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64890       };
64891     }
64892   }
64893 }
64894
64895
64896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
64897   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64898
64899   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64900   {
64901     try {
64902       delete arg1;
64903     } catch (std::out_of_range& e) {
64904       {
64905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64906       };
64907     } catch (std::exception& e) {
64908       {
64909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64910       };
64911     } catch (...) {
64912       {
64913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64914       };
64915     }
64916   }
64917 }
64918
64919
64920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
64921   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64922   Dali::Toolkit::ControlOrientation::Type arg2 ;
64923
64924   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64925   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
64926   {
64927     try {
64928       (arg1)->SetOrientation(arg2);
64929     } catch (std::out_of_range& e) {
64930       {
64931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64932       };
64933     } catch (std::exception& e) {
64934       {
64935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64936       };
64937     } catch (...) {
64938       {
64939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64940       };
64941     }
64942   }
64943 }
64944
64945
64946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
64947   int jresult ;
64948   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64949   Dali::Toolkit::ControlOrientation::Type result;
64950
64951   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64952   {
64953     try {
64954       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
64955     } catch (std::out_of_range& e) {
64956       {
64957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64958       };
64959     } catch (std::exception& e) {
64960       {
64961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64962       };
64963     } catch (...) {
64964       {
64965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64966       };
64967     }
64968   }
64969   jresult = (int)result;
64970   return jresult;
64971 }
64972
64973
64974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64975   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64976   unsigned int arg2 ;
64977   Dali::Vector3 *arg3 = 0 ;
64978   Dali::Vector3 *arg4 = 0 ;
64979
64980   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64981   arg2 = (unsigned int)jarg2;
64982   arg3 = (Dali::Vector3 *)jarg3;
64983   if (!arg3) {
64984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64985     return ;
64986   }
64987   arg4 = (Dali::Vector3 *)jarg4;
64988   if (!arg4) {
64989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64990     return ;
64991   }
64992   {
64993     try {
64994       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64995     } catch (std::out_of_range& e) {
64996       {
64997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64998       };
64999     } catch (std::exception& e) {
65000       {
65001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65002       };
65003     } catch (...) {
65004       {
65005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65006       };
65007     }
65008   }
65009 }
65010
65011
65012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
65013   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65014   Dali::Vector3 *arg2 = 0 ;
65015
65016   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65017   arg2 = (Dali::Vector3 *)jarg2;
65018   if (!arg2) {
65019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65020     return ;
65021   }
65022   {
65023     try {
65024       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
65025     } catch (std::out_of_range& e) {
65026       {
65027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65028       };
65029     } catch (std::exception& e) {
65030       {
65031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65032       };
65033     } catch (...) {
65034       {
65035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65036       };
65037     }
65038   }
65039 }
65040
65041
65042 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
65043   float jresult ;
65044   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65045   unsigned int arg2 ;
65046   Dali::Vector3 arg3 ;
65047   Dali::Vector3 *argp3 ;
65048   float result;
65049
65050   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65051   arg2 = (unsigned int)jarg2;
65052   argp3 = (Dali::Vector3 *)jarg3;
65053   if (!argp3) {
65054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
65055     return 0;
65056   }
65057   arg3 = *argp3;
65058   {
65059     try {
65060       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
65061     } catch (std::out_of_range& e) {
65062       {
65063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65064       };
65065     } catch (std::exception& e) {
65066       {
65067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65068       };
65069     } catch (...) {
65070       {
65071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65072       };
65073     }
65074   }
65075   jresult = result;
65076   return jresult;
65077 }
65078
65079
65080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
65081   float jresult ;
65082   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65083   float arg2 ;
65084   float result;
65085
65086   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65087   arg2 = (float)jarg2;
65088   {
65089     try {
65090       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
65091     } catch (std::out_of_range& e) {
65092       {
65093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65094       };
65095     } catch (std::exception& e) {
65096       {
65097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65098       };
65099     } catch (...) {
65100       {
65101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65102       };
65103     }
65104   }
65105   jresult = result;
65106   return jresult;
65107 }
65108
65109
65110 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
65111   float jresult ;
65112   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65113   unsigned int arg2 ;
65114   float result;
65115
65116   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65117   arg2 = (unsigned int)jarg2;
65118   {
65119     try {
65120       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
65121     } catch (std::out_of_range& e) {
65122       {
65123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65124       };
65125     } catch (std::exception& e) {
65126       {
65127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65128       };
65129     } catch (...) {
65130       {
65131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65132       };
65133     }
65134   }
65135   jresult = result;
65136   return jresult;
65137 }
65138
65139
65140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
65141   void * jresult ;
65142   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65143   float arg2 ;
65144   Dali::Vector3 arg3 ;
65145   Dali::Vector3 *argp3 ;
65146   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
65147
65148   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65149   arg2 = (float)jarg2;
65150   argp3 = (Dali::Vector3 *)jarg3;
65151   if (!argp3) {
65152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
65153     return 0;
65154   }
65155   arg3 = *argp3;
65156   {
65157     try {
65158       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
65159     } catch (std::out_of_range& e) {
65160       {
65161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65162       };
65163     } catch (std::exception& e) {
65164       {
65165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65166       };
65167     } catch (...) {
65168       {
65169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65170       };
65171     }
65172   }
65173   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
65174   return jresult;
65175 }
65176
65177
65178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65179   float jresult ;
65180   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65181   int arg2 ;
65182   float arg3 ;
65183   Dali::Vector3 *arg4 = 0 ;
65184   float result;
65185
65186   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65187   arg2 = (int)jarg2;
65188   arg3 = (float)jarg3;
65189   arg4 = (Dali::Vector3 *)jarg4;
65190   if (!arg4) {
65191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65192     return 0;
65193   }
65194   {
65195     try {
65196       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65197     } catch (std::out_of_range& e) {
65198       {
65199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65200       };
65201     } catch (std::exception& e) {
65202       {
65203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65204       };
65205     } catch (...) {
65206       {
65207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65208       };
65209     }
65210   }
65211   jresult = result;
65212   return jresult;
65213 }
65214
65215
65216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
65217   unsigned int jresult ;
65218   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65219   Dali::Vector3 arg2 ;
65220   Dali::Vector3 *argp2 ;
65221   unsigned int result;
65222
65223   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65224   argp2 = (Dali::Vector3 *)jarg2;
65225   if (!argp2) {
65226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
65227     return 0;
65228   }
65229   arg2 = *argp2;
65230   {
65231     try {
65232       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
65233     } catch (std::out_of_range& e) {
65234       {
65235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65236       };
65237     } catch (std::exception& e) {
65238       {
65239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65240       };
65241     } catch (...) {
65242       {
65243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65244       };
65245     }
65246   }
65247   jresult = result;
65248   return jresult;
65249 }
65250
65251
65252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
65253   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65254   unsigned int arg2 ;
65255   Dali::Vector3 *arg3 = 0 ;
65256   Dali::Vector3 *arg4 = 0 ;
65257
65258   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65259   arg2 = (unsigned int)jarg2;
65260   arg3 = (Dali::Vector3 *)jarg3;
65261   if (!arg3) {
65262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65263     return ;
65264   }
65265   arg4 = (Dali::Vector3 *)jarg4;
65266   if (!arg4) {
65267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
65268     return ;
65269   }
65270   {
65271     try {
65272       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
65273     } catch (std::out_of_range& e) {
65274       {
65275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65276       };
65277     } catch (std::exception& e) {
65278       {
65279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65280       };
65281     } catch (...) {
65282       {
65283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65284       };
65285     }
65286   }
65287 }
65288
65289
65290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
65291   void * jresult ;
65292   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65293   Dali::Degree result;
65294
65295   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65296   {
65297     try {
65298       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
65299     } catch (std::out_of_range& e) {
65300       {
65301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65302       };
65303     } catch (std::exception& e) {
65304       {
65305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65306       };
65307     } catch (...) {
65308       {
65309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65310       };
65311     }
65312   }
65313   jresult = new Dali::Degree((const Dali::Degree &)result);
65314   return jresult;
65315 }
65316
65317
65318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
65319   float jresult ;
65320   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65321   float result;
65322
65323   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65324   {
65325     try {
65326       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
65327     } catch (std::out_of_range& e) {
65328       {
65329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65330       };
65331     } catch (std::exception& e) {
65332       {
65333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65334       };
65335     } catch (...) {
65336       {
65337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65338       };
65339     }
65340   }
65341   jresult = result;
65342   return jresult;
65343 }
65344
65345
65346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
65347   float jresult ;
65348   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65349   float result;
65350
65351   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65352   {
65353     try {
65354       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
65355     } catch (std::out_of_range& e) {
65356       {
65357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65358       };
65359     } catch (std::exception& e) {
65360       {
65361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65362       };
65363     } catch (...) {
65364       {
65365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65366       };
65367     }
65368   }
65369   jresult = result;
65370   return jresult;
65371 }
65372
65373
65374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
65375   float jresult ;
65376   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65377   float result;
65378
65379   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65380   {
65381     try {
65382       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
65383     } catch (std::out_of_range& e) {
65384       {
65385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65386       };
65387     } catch (std::exception& e) {
65388       {
65389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65390       };
65391     } catch (...) {
65392       {
65393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65394       };
65395     }
65396   }
65397   jresult = result;
65398   return jresult;
65399 }
65400
65401
65402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
65403   int jresult ;
65404   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65405   int arg2 ;
65406   int arg3 ;
65407   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
65408   bool arg5 ;
65409   int result;
65410
65411   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65412   arg2 = (int)jarg2;
65413   arg3 = (int)jarg3;
65414   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
65415   arg5 = jarg5 ? true : false;
65416   {
65417     try {
65418       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
65419     } catch (std::out_of_range& e) {
65420       {
65421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65422       };
65423     } catch (std::exception& e) {
65424       {
65425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65426       };
65427     } catch (...) {
65428       {
65429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65430       };
65431     }
65432   }
65433   jresult = result;
65434   return jresult;
65435 }
65436
65437
65438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
65439   float jresult ;
65440   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65441   float result;
65442
65443   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65444   {
65445     try {
65446       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
65447     } catch (std::out_of_range& e) {
65448       {
65449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65450       };
65451     } catch (std::exception& e) {
65452       {
65453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65454       };
65455     } catch (...) {
65456       {
65457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65458       };
65459     }
65460   }
65461   jresult = result;
65462   return jresult;
65463 }
65464
65465
65466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
65467   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65468   Dali::Actor *arg2 = 0 ;
65469   int arg3 ;
65470   Dali::Vector3 *arg4 = 0 ;
65471   Dali::Actor *arg5 = 0 ;
65472
65473   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65474   arg2 = (Dali::Actor *)jarg2;
65475   if (!arg2) {
65476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65477     return ;
65478   }
65479   arg3 = (int)jarg3;
65480   arg4 = (Dali::Vector3 *)jarg4;
65481   if (!arg4) {
65482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65483     return ;
65484   }
65485   arg5 = (Dali::Actor *)jarg5;
65486   if (!arg5) {
65487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65488     return ;
65489   }
65490   {
65491     try {
65492       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
65493     } catch (std::out_of_range& e) {
65494       {
65495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65496       };
65497     } catch (std::exception& e) {
65498       {
65499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65500       };
65501     } catch (...) {
65502       {
65503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65504       };
65505     }
65506   }
65507 }
65508
65509
65510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65511   void * jresult ;
65512   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65513   int arg2 ;
65514   float arg3 ;
65515   Dali::Vector3 *arg4 = 0 ;
65516   Dali::Vector3 result;
65517
65518   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65519   arg2 = (int)jarg2;
65520   arg3 = (float)jarg3;
65521   arg4 = (Dali::Vector3 *)jarg4;
65522   if (!arg4) {
65523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65524     return 0;
65525   }
65526   {
65527     try {
65528       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65529     } catch (std::out_of_range& e) {
65530       {
65531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65532       };
65533     } catch (std::exception& e) {
65534       {
65535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65536       };
65537     } catch (...) {
65538       {
65539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65540       };
65541     }
65542   }
65543   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65544   return jresult;
65545 }
65546
65547
65548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
65549   void * jresult ;
65550   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
65551   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65552
65553   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
65554   {
65555     try {
65556       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
65557     } catch (std::out_of_range& e) {
65558       {
65559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65560       };
65561     } catch (std::exception& e) {
65562       {
65563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65564       };
65565     } catch (...) {
65566       {
65567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65568       };
65569     }
65570   }
65571   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65572   return jresult;
65573 }
65574
65575
65576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
65577   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65578
65579   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65580   {
65581     try {
65582       delete arg1;
65583     } catch (std::out_of_range& e) {
65584       {
65585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65586       };
65587     } catch (std::exception& e) {
65588       {
65589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65590       };
65591     } catch (...) {
65592       {
65593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65594       };
65595     }
65596   }
65597 }
65598
65599
65600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
65601   unsigned int jresult ;
65602   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65603   unsigned int result;
65604
65605   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65606   {
65607     try {
65608       result = (unsigned int)(arg1)->GetNumberOfItems();
65609     } catch (std::out_of_range& e) {
65610       {
65611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65612       };
65613     } catch (std::exception& e) {
65614       {
65615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65616       };
65617     } catch (...) {
65618       {
65619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65620       };
65621     }
65622   }
65623   jresult = result;
65624   return jresult;
65625 }
65626
65627
65628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
65629   void * jresult ;
65630   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65631   unsigned int arg2 ;
65632   Dali::Actor result;
65633
65634   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65635   arg2 = (unsigned int)jarg2;
65636   {
65637     try {
65638       result = (arg1)->NewItem(arg2);
65639     } catch (std::out_of_range& e) {
65640       {
65641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65642       };
65643     } catch (std::exception& e) {
65644       {
65645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65646       };
65647     } catch (...) {
65648       {
65649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65650       };
65651     }
65652   }
65653   jresult = new Dali::Actor((const Dali::Actor &)result);
65654   return jresult;
65655 }
65656
65657
65658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
65659   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65660   unsigned int arg2 ;
65661   Dali::Actor arg3 ;
65662   Dali::Actor *argp3 ;
65663
65664   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65665   arg2 = (unsigned int)jarg2;
65666   argp3 = (Dali::Actor *)jarg3;
65667   if (!argp3) {
65668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65669     return ;
65670   }
65671   arg3 = *argp3;
65672   {
65673     try {
65674       (arg1)->ItemReleased(arg2,arg3);
65675     } catch (std::out_of_range& e) {
65676       {
65677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65678       };
65679     } catch (std::exception& e) {
65680       {
65681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65682       };
65683     } catch (...) {
65684       {
65685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65686       };
65687     }
65688   }
65689 }
65690
65691
65692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
65693   int jresult ;
65694   int result;
65695
65696   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
65697   jresult = (int)result;
65698   return jresult;
65699 }
65700
65701
65702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
65703   int jresult ;
65704   int result;
65705
65706   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
65707   jresult = (int)result;
65708   return jresult;
65709 }
65710
65711
65712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
65713   int jresult ;
65714   int result;
65715
65716   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
65717   jresult = (int)result;
65718   return jresult;
65719 }
65720
65721
65722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
65723   int jresult ;
65724   int result;
65725
65726   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
65727   jresult = (int)result;
65728   return jresult;
65729 }
65730
65731
65732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
65733   int jresult ;
65734   int result;
65735
65736   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
65737   jresult = (int)result;
65738   return jresult;
65739 }
65740
65741
65742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
65743   int jresult ;
65744   int result;
65745
65746   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
65747   jresult = (int)result;
65748   return jresult;
65749 }
65750
65751
65752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
65753   int jresult ;
65754   int result;
65755
65756   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
65757   jresult = (int)result;
65758   return jresult;
65759 }
65760
65761
65762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
65763   int jresult ;
65764   int result;
65765
65766   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
65767   jresult = (int)result;
65768   return jresult;
65769 }
65770
65771
65772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
65773   int jresult ;
65774   int result;
65775
65776   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
65777   jresult = (int)result;
65778   return jresult;
65779 }
65780
65781
65782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
65783   int jresult ;
65784   int result;
65785
65786   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
65787   jresult = (int)result;
65788   return jresult;
65789 }
65790
65791
65792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
65793   int jresult ;
65794   int result;
65795
65796   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
65797   jresult = (int)result;
65798   return jresult;
65799 }
65800
65801
65802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
65803   void * jresult ;
65804   Dali::Toolkit::ItemView::Property *result = 0 ;
65805
65806   {
65807     try {
65808       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
65809     } catch (std::out_of_range& e) {
65810       {
65811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65812       };
65813     } catch (std::exception& e) {
65814       {
65815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65816       };
65817     } catch (...) {
65818       {
65819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65820       };
65821     }
65822   }
65823   jresult = (void *)result;
65824   return jresult;
65825 }
65826
65827
65828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
65829   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
65830
65831   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
65832   {
65833     try {
65834       delete arg1;
65835     } catch (std::out_of_range& e) {
65836       {
65837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65838       };
65839     } catch (std::exception& e) {
65840       {
65841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65842       };
65843     } catch (...) {
65844       {
65845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65846       };
65847     }
65848   }
65849 }
65850
65851
65852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
65853   void * jresult ;
65854   Dali::Toolkit::ItemView *result = 0 ;
65855
65856   {
65857     try {
65858       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
65859     } catch (std::out_of_range& e) {
65860       {
65861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65862       };
65863     } catch (std::exception& e) {
65864       {
65865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65866       };
65867     } catch (...) {
65868       {
65869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65870       };
65871     }
65872   }
65873   jresult = (void *)result;
65874   return jresult;
65875 }
65876
65877
65878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
65879   void * jresult ;
65880   Dali::Toolkit::ItemView *arg1 = 0 ;
65881   Dali::Toolkit::ItemView *result = 0 ;
65882
65883   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65884   if (!arg1) {
65885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65886     return 0;
65887   }
65888   {
65889     try {
65890       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
65891     } catch (std::out_of_range& e) {
65892       {
65893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65894       };
65895     } catch (std::exception& e) {
65896       {
65897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65898       };
65899     } catch (...) {
65900       {
65901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65902       };
65903     }
65904   }
65905   jresult = (void *)result;
65906   return jresult;
65907 }
65908
65909
65910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
65911   void * jresult ;
65912   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65913   Dali::Toolkit::ItemView *arg2 = 0 ;
65914   Dali::Toolkit::ItemView *result = 0 ;
65915
65916   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65917   arg2 = (Dali::Toolkit::ItemView *)jarg2;
65918   if (!arg2) {
65919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65920     return 0;
65921   }
65922   {
65923     try {
65924       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
65925     } catch (std::out_of_range& e) {
65926       {
65927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65928       };
65929     } catch (std::exception& e) {
65930       {
65931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65932       };
65933     } catch (...) {
65934       {
65935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65936       };
65937     }
65938   }
65939   jresult = (void *)result;
65940   return jresult;
65941 }
65942
65943
65944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
65945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65946
65947   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65948   {
65949     try {
65950       delete arg1;
65951     } catch (std::out_of_range& e) {
65952       {
65953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65954       };
65955     } catch (std::exception& e) {
65956       {
65957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65958       };
65959     } catch (...) {
65960       {
65961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65962       };
65963     }
65964   }
65965 }
65966
65967
65968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
65969   void * jresult ;
65970   Dali::Toolkit::ItemFactory *arg1 = 0 ;
65971   Dali::Toolkit::ItemView result;
65972
65973   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65974   if (!arg1) {
65975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
65976     return 0;
65977   }
65978   {
65979     try {
65980       result = Dali::Toolkit::ItemView::New(*arg1);
65981     } catch (std::out_of_range& e) {
65982       {
65983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65984       };
65985     } catch (std::exception& e) {
65986       {
65987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65988       };
65989     } catch (...) {
65990       {
65991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65992       };
65993     }
65994   }
65995   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65996   return jresult;
65997 }
65998
65999
66000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
66001   void * jresult ;
66002   Dali::BaseHandle arg1 ;
66003   Dali::BaseHandle *argp1 ;
66004   Dali::Toolkit::ItemView result;
66005
66006   argp1 = (Dali::BaseHandle *)jarg1;
66007   if (!argp1) {
66008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66009     return 0;
66010   }
66011   arg1 = *argp1;
66012   {
66013     try {
66014       result = Dali::Toolkit::ItemView::DownCast(arg1);
66015     } catch (std::out_of_range& e) {
66016       {
66017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66018       };
66019     } catch (std::exception& e) {
66020       {
66021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66022       };
66023     } catch (...) {
66024       {
66025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66026       };
66027     }
66028   }
66029   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
66030   return jresult;
66031 }
66032
66033
66034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
66035   unsigned int jresult ;
66036   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66037   unsigned int result;
66038
66039   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66040   {
66041     try {
66042       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
66043     } catch (std::out_of_range& e) {
66044       {
66045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66046       };
66047     } catch (std::exception& e) {
66048       {
66049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66050       };
66051     } catch (...) {
66052       {
66053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66054       };
66055     }
66056   }
66057   jresult = result;
66058   return jresult;
66059 }
66060
66061
66062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
66063   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66064   Dali::Toolkit::ItemLayout *arg2 = 0 ;
66065
66066   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66067   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
66068   if (!arg2) {
66069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
66070     return ;
66071   }
66072   {
66073     try {
66074       (arg1)->AddLayout(*arg2);
66075     } catch (std::out_of_range& e) {
66076       {
66077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66078       };
66079     } catch (std::exception& e) {
66080       {
66081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66082       };
66083     } catch (...) {
66084       {
66085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66086       };
66087     }
66088   }
66089 }
66090
66091
66092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
66093   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66094   unsigned int arg2 ;
66095
66096   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66097   arg2 = (unsigned int)jarg2;
66098   {
66099     try {
66100       (arg1)->RemoveLayout(arg2);
66101     } catch (std::out_of_range& e) {
66102       {
66103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66104       };
66105     } catch (std::exception& e) {
66106       {
66107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66108       };
66109     } catch (...) {
66110       {
66111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66112       };
66113     }
66114   }
66115 }
66116
66117
66118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
66119   void * jresult ;
66120   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66121   unsigned int arg2 ;
66122   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
66123
66124   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66125   arg2 = (unsigned int)jarg2;
66126   {
66127     try {
66128       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
66129     } catch (std::out_of_range& e) {
66130       {
66131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66132       };
66133     } catch (std::exception& e) {
66134       {
66135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66136       };
66137     } catch (...) {
66138       {
66139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66140       };
66141     }
66142   }
66143   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
66144   return jresult;
66145 }
66146
66147
66148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
66149   void * jresult ;
66150   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66151   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
66152
66153   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66154   {
66155     try {
66156       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
66157     } catch (std::out_of_range& e) {
66158       {
66159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66160       };
66161     } catch (std::exception& e) {
66162       {
66163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66164       };
66165     } catch (...) {
66166       {
66167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66168       };
66169     }
66170   }
66171   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
66172   return jresult;
66173 }
66174
66175
66176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
66177   float jresult ;
66178   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66179   Dali::Toolkit::ItemId arg2 ;
66180   float result;
66181
66182   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66183   arg2 = (Dali::Toolkit::ItemId)jarg2;
66184   {
66185     try {
66186       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
66187     } catch (std::out_of_range& e) {
66188       {
66189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66190       };
66191     } catch (std::exception& e) {
66192       {
66193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66194       };
66195     } catch (...) {
66196       {
66197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66198       };
66199     }
66200   }
66201   jresult = result;
66202   return jresult;
66203 }
66204
66205
66206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
66207   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66208   unsigned int arg2 ;
66209   Dali::Vector3 arg3 ;
66210   float arg4 ;
66211   Dali::Vector3 *argp3 ;
66212
66213   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66214   arg2 = (unsigned int)jarg2;
66215   argp3 = (Dali::Vector3 *)jarg3;
66216   if (!argp3) {
66217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
66218     return ;
66219   }
66220   arg3 = *argp3;
66221   arg4 = (float)jarg4;
66222   {
66223     try {
66224       (arg1)->ActivateLayout(arg2,arg3,arg4);
66225     } catch (std::out_of_range& e) {
66226       {
66227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66228       };
66229     } catch (std::exception& e) {
66230       {
66231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66232       };
66233     } catch (...) {
66234       {
66235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66236       };
66237     }
66238   }
66239 }
66240
66241
66242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
66243   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66244
66245   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66246   {
66247     try {
66248       (arg1)->DeactivateCurrentLayout();
66249     } catch (std::out_of_range& e) {
66250       {
66251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66252       };
66253     } catch (std::exception& e) {
66254       {
66255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66256       };
66257     } catch (...) {
66258       {
66259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66260       };
66261     }
66262   }
66263 }
66264
66265
66266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
66267   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66268   float arg2 ;
66269
66270   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66271   arg2 = (float)jarg2;
66272   {
66273     try {
66274       (arg1)->SetMinimumSwipeSpeed(arg2);
66275     } catch (std::out_of_range& e) {
66276       {
66277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66278       };
66279     } catch (std::exception& e) {
66280       {
66281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66282       };
66283     } catch (...) {
66284       {
66285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66286       };
66287     }
66288   }
66289 }
66290
66291
66292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
66293   float jresult ;
66294   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66295   float result;
66296
66297   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66298   {
66299     try {
66300       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
66301     } catch (std::out_of_range& e) {
66302       {
66303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66304       };
66305     } catch (std::exception& e) {
66306       {
66307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66308       };
66309     } catch (...) {
66310       {
66311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66312       };
66313     }
66314   }
66315   jresult = result;
66316   return jresult;
66317 }
66318
66319
66320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
66321   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66322   float arg2 ;
66323
66324   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66325   arg2 = (float)jarg2;
66326   {
66327     try {
66328       (arg1)->SetMinimumSwipeDistance(arg2);
66329     } catch (std::out_of_range& e) {
66330       {
66331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66332       };
66333     } catch (std::exception& e) {
66334       {
66335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66336       };
66337     } catch (...) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66340       };
66341     }
66342   }
66343 }
66344
66345
66346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
66347   float jresult ;
66348   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66349   float result;
66350
66351   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66352   {
66353     try {
66354       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
66355     } catch (std::out_of_range& e) {
66356       {
66357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66358       };
66359     } catch (std::exception& e) {
66360       {
66361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66362       };
66363     } catch (...) {
66364       {
66365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66366       };
66367     }
66368   }
66369   jresult = result;
66370   return jresult;
66371 }
66372
66373
66374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
66375   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66376   float arg2 ;
66377
66378   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66379   arg2 = (float)jarg2;
66380   {
66381     try {
66382       (arg1)->SetWheelScrollDistanceStep(arg2);
66383     } catch (std::out_of_range& e) {
66384       {
66385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66386       };
66387     } catch (std::exception& e) {
66388       {
66389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66390       };
66391     } catch (...) {
66392       {
66393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66394       };
66395     }
66396   }
66397 }
66398
66399
66400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
66401   float jresult ;
66402   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66403   float result;
66404
66405   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66406   {
66407     try {
66408       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
66409     } catch (std::out_of_range& e) {
66410       {
66411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66412       };
66413     } catch (std::exception& e) {
66414       {
66415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66416       };
66417     } catch (...) {
66418       {
66419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66420       };
66421     }
66422   }
66423   jresult = result;
66424   return jresult;
66425 }
66426
66427
66428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
66429   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66430   bool arg2 ;
66431
66432   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66433   arg2 = jarg2 ? true : false;
66434   {
66435     try {
66436       (arg1)->SetAnchoring(arg2);
66437     } catch (std::out_of_range& e) {
66438       {
66439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66440       };
66441     } catch (std::exception& e) {
66442       {
66443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66444       };
66445     } catch (...) {
66446       {
66447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66448       };
66449     }
66450   }
66451 }
66452
66453
66454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
66455   unsigned int jresult ;
66456   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66457   bool result;
66458
66459   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66460   {
66461     try {
66462       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
66463     } catch (std::out_of_range& e) {
66464       {
66465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66466       };
66467     } catch (std::exception& e) {
66468       {
66469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66470       };
66471     } catch (...) {
66472       {
66473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66474       };
66475     }
66476   }
66477   jresult = result;
66478   return jresult;
66479 }
66480
66481
66482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
66483   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66484   float arg2 ;
66485
66486   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66487   arg2 = (float)jarg2;
66488   {
66489     try {
66490       (arg1)->SetAnchoringDuration(arg2);
66491     } catch (std::out_of_range& e) {
66492       {
66493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66494       };
66495     } catch (std::exception& e) {
66496       {
66497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66498       };
66499     } catch (...) {
66500       {
66501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66502       };
66503     }
66504   }
66505 }
66506
66507
66508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
66509   float jresult ;
66510   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66511   float result;
66512
66513   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66514   {
66515     try {
66516       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
66517     } catch (std::out_of_range& e) {
66518       {
66519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66520       };
66521     } catch (std::exception& e) {
66522       {
66523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66524       };
66525     } catch (...) {
66526       {
66527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66528       };
66529     }
66530   }
66531   jresult = result;
66532   return jresult;
66533 }
66534
66535
66536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
66537   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66538   Dali::Toolkit::ItemId arg2 ;
66539   float arg3 ;
66540
66541   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66542   arg2 = (Dali::Toolkit::ItemId)jarg2;
66543   arg3 = (float)jarg3;
66544   {
66545     try {
66546       (arg1)->ScrollToItem(arg2,arg3);
66547     } catch (std::out_of_range& e) {
66548       {
66549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66550       };
66551     } catch (std::exception& e) {
66552       {
66553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66554       };
66555     } catch (...) {
66556       {
66557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66558       };
66559     }
66560   }
66561 }
66562
66563
66564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
66565   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66566   float arg2 ;
66567
66568   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66569   arg2 = (float)jarg2;
66570   {
66571     try {
66572       (arg1)->SetRefreshInterval(arg2);
66573     } catch (std::out_of_range& e) {
66574       {
66575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66576       };
66577     } catch (std::exception& e) {
66578       {
66579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66580       };
66581     } catch (...) {
66582       {
66583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66584       };
66585     }
66586   }
66587 }
66588
66589
66590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
66591   float jresult ;
66592   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66593   float result;
66594
66595   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66596   {
66597     try {
66598       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
66599     } catch (std::out_of_range& e) {
66600       {
66601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66602       };
66603     } catch (std::exception& e) {
66604       {
66605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66606       };
66607     } catch (...) {
66608       {
66609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66610       };
66611     }
66612   }
66613   jresult = result;
66614   return jresult;
66615 }
66616
66617
66618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
66619   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66620
66621   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66622   {
66623     try {
66624       (arg1)->Refresh();
66625     } catch (std::out_of_range& e) {
66626       {
66627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66628       };
66629     } catch (std::exception& e) {
66630       {
66631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66632       };
66633     } catch (...) {
66634       {
66635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66636       };
66637     }
66638   }
66639 }
66640
66641
66642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
66643   void * jresult ;
66644   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66645   Dali::Toolkit::ItemId arg2 ;
66646   Dali::Actor result;
66647
66648   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66649   arg2 = (Dali::Toolkit::ItemId)jarg2;
66650   {
66651     try {
66652       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
66653     } catch (std::out_of_range& e) {
66654       {
66655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66656       };
66657     } catch (std::exception& e) {
66658       {
66659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66660       };
66661     } catch (...) {
66662       {
66663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66664       };
66665     }
66666   }
66667   jresult = new Dali::Actor((const Dali::Actor &)result);
66668   return jresult;
66669 }
66670
66671
66672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
66673   unsigned int jresult ;
66674   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66675   Dali::Actor arg2 ;
66676   Dali::Actor *argp2 ;
66677   Dali::Toolkit::ItemId result;
66678
66679   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66680   argp2 = (Dali::Actor *)jarg2;
66681   if (!argp2) {
66682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66683     return 0;
66684   }
66685   arg2 = *argp2;
66686   {
66687     try {
66688       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
66689     } catch (std::out_of_range& e) {
66690       {
66691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66692       };
66693     } catch (std::exception& e) {
66694       {
66695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66696       };
66697     } catch (...) {
66698       {
66699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66700       };
66701     }
66702   }
66703   jresult = result;
66704   return jresult;
66705 }
66706
66707
66708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
66709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66710   Dali::Toolkit::Item arg2 ;
66711   float arg3 ;
66712   Dali::Toolkit::Item *argp2 ;
66713
66714   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66715   argp2 = (Dali::Toolkit::Item *)jarg2;
66716   if (!argp2) {
66717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66718     return ;
66719   }
66720   arg2 = *argp2;
66721   arg3 = (float)jarg3;
66722   {
66723     try {
66724       (arg1)->InsertItem(arg2,arg3);
66725     } catch (std::out_of_range& e) {
66726       {
66727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66728       };
66729     } catch (std::exception& e) {
66730       {
66731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66732       };
66733     } catch (...) {
66734       {
66735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66736       };
66737     }
66738   }
66739 }
66740
66741
66742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
66743   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66744   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66745   float arg3 ;
66746
66747   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66748   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66749   if (!arg2) {
66750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66751     return ;
66752   }
66753   arg3 = (float)jarg3;
66754   {
66755     try {
66756       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66757     } catch (std::out_of_range& e) {
66758       {
66759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66760       };
66761     } catch (std::exception& e) {
66762       {
66763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66764       };
66765     } catch (...) {
66766       {
66767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66768       };
66769     }
66770   }
66771 }
66772
66773
66774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
66775   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66776   Dali::Toolkit::ItemId arg2 ;
66777   float arg3 ;
66778
66779   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66780   arg2 = (Dali::Toolkit::ItemId)jarg2;
66781   arg3 = (float)jarg3;
66782   {
66783     try {
66784       (arg1)->RemoveItem(arg2,arg3);
66785     } catch (std::out_of_range& e) {
66786       {
66787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66788       };
66789     } catch (std::exception& e) {
66790       {
66791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66792       };
66793     } catch (...) {
66794       {
66795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66796       };
66797     }
66798   }
66799 }
66800
66801
66802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
66803   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66804   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
66805   float arg3 ;
66806
66807   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66808   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
66809   if (!arg2) {
66810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
66811     return ;
66812   }
66813   arg3 = (float)jarg3;
66814   {
66815     try {
66816       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
66817     } catch (std::out_of_range& e) {
66818       {
66819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66820       };
66821     } catch (std::exception& e) {
66822       {
66823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66824       };
66825     } catch (...) {
66826       {
66827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66828       };
66829     }
66830   }
66831 }
66832
66833
66834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
66835   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66836   Dali::Toolkit::Item arg2 ;
66837   float arg3 ;
66838   Dali::Toolkit::Item *argp2 ;
66839
66840   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66841   argp2 = (Dali::Toolkit::Item *)jarg2;
66842   if (!argp2) {
66843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66844     return ;
66845   }
66846   arg2 = *argp2;
66847   arg3 = (float)jarg3;
66848   {
66849     try {
66850       (arg1)->ReplaceItem(arg2,arg3);
66851     } catch (std::out_of_range& e) {
66852       {
66853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66854       };
66855     } catch (std::exception& e) {
66856       {
66857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66858       };
66859     } catch (...) {
66860       {
66861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66862       };
66863     }
66864   }
66865 }
66866
66867
66868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
66869   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66870   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66871   float arg3 ;
66872
66873   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66874   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66875   if (!arg2) {
66876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66877     return ;
66878   }
66879   arg3 = (float)jarg3;
66880   {
66881     try {
66882       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66883     } catch (std::out_of_range& e) {
66884       {
66885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66886       };
66887     } catch (std::exception& e) {
66888       {
66889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66890       };
66891     } catch (...) {
66892       {
66893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66894       };
66895     }
66896   }
66897 }
66898
66899
66900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
66901   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66902   Dali::Vector3 *arg2 = 0 ;
66903
66904   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66905   arg2 = (Dali::Vector3 *)jarg2;
66906   if (!arg2) {
66907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66908     return ;
66909   }
66910   {
66911     try {
66912       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
66913     } catch (std::out_of_range& e) {
66914       {
66915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66916       };
66917     } catch (std::exception& e) {
66918       {
66919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66920       };
66921     } catch (...) {
66922       {
66923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66924       };
66925     }
66926   }
66927 }
66928
66929
66930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
66931   void * jresult ;
66932   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66933   Dali::Vector3 result;
66934
66935   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66936   {
66937     try {
66938       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
66939     } catch (std::out_of_range& e) {
66940       {
66941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66942       };
66943     } catch (std::exception& e) {
66944       {
66945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66946       };
66947     } catch (...) {
66948       {
66949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66950       };
66951     }
66952   }
66953   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66954   return jresult;
66955 }
66956
66957
66958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
66959   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66960   Dali::Vector3 *arg2 = 0 ;
66961
66962   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66963   arg2 = (Dali::Vector3 *)jarg2;
66964   if (!arg2) {
66965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66966     return ;
66967   }
66968   {
66969     try {
66970       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
66971     } catch (std::out_of_range& e) {
66972       {
66973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66974       };
66975     } catch (std::exception& e) {
66976       {
66977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66978       };
66979     } catch (...) {
66980       {
66981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66982       };
66983     }
66984   }
66985 }
66986
66987
66988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
66989   void * jresult ;
66990   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66991   Dali::Vector3 result;
66992
66993   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66994   {
66995     try {
66996       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
66997     } catch (std::out_of_range& e) {
66998       {
66999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67000       };
67001     } catch (std::exception& e) {
67002       {
67003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67004       };
67005     } catch (...) {
67006       {
67007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67008       };
67009     }
67010   }
67011   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
67012   return jresult;
67013 }
67014
67015
67016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
67017   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67018   Dali::Toolkit::ItemRange *arg2 = 0 ;
67019
67020   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67021   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
67022   if (!arg2) {
67023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
67024     return ;
67025   }
67026   {
67027     try {
67028       (arg1)->GetItemsRange(*arg2);
67029     } catch (std::out_of_range& e) {
67030       {
67031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67032       };
67033     } catch (std::exception& e) {
67034       {
67035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67036       };
67037     } catch (...) {
67038       {
67039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67040       };
67041     }
67042   }
67043 }
67044
67045
67046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
67047   void * jresult ;
67048   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67049   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
67050
67051   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67052   {
67053     try {
67054       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
67055     } catch (std::out_of_range& e) {
67056       {
67057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67058       };
67059     } catch (std::exception& e) {
67060       {
67061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67062       };
67063     } catch (...) {
67064       {
67065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67066       };
67067     }
67068   }
67069   jresult = (void *)result;
67070   return jresult;
67071 }
67072
67073
67074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
67075   Dali::Vector3 *arg1 = 0 ;
67076   PropertyInputContainer *arg2 = 0 ;
67077
67078   arg1 = (Dali::Vector3 *)jarg1;
67079   if (!arg1) {
67080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
67081     return ;
67082   }
67083   arg2 = (PropertyInputContainer *)jarg2;
67084   if (!arg2) {
67085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
67086     return ;
67087   }
67088   {
67089     try {
67090       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
67091     } catch (std::out_of_range& e) {
67092       {
67093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67094       };
67095     } catch (std::exception& e) {
67096       {
67097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67098       };
67099     } catch (...) {
67100       {
67101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67102       };
67103     }
67104   }
67105 }
67106
67107
67108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
67109   Dali::Vector3 *arg1 = 0 ;
67110   PropertyInputContainer *arg2 = 0 ;
67111
67112   arg1 = (Dali::Vector3 *)jarg1;
67113   if (!arg1) {
67114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
67115     return ;
67116   }
67117   arg2 = (PropertyInputContainer *)jarg2;
67118   if (!arg2) {
67119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
67120     return ;
67121   }
67122   {
67123     try {
67124       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
67125     } catch (std::out_of_range& e) {
67126       {
67127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67128       };
67129     } catch (std::exception& e) {
67130       {
67131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67132       };
67133     } catch (...) {
67134       {
67135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67136       };
67137     }
67138   }
67139 }
67140
67141
67142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
67143   void * jresult ;
67144   Dali::Toolkit::ScrollViewEffect *result = 0 ;
67145
67146   {
67147     try {
67148       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
67149     } catch (std::out_of_range& e) {
67150       {
67151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67152       };
67153     } catch (std::exception& e) {
67154       {
67155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67156       };
67157     } catch (...) {
67158       {
67159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67160       };
67161     }
67162   }
67163   jresult = (void *)result;
67164   return jresult;
67165 }
67166
67167
67168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
67169   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
67170
67171   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
67172   {
67173     try {
67174       delete arg1;
67175     } catch (std::out_of_range& e) {
67176       {
67177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67178       };
67179     } catch (std::exception& e) {
67180       {
67181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67182       };
67183     } catch (...) {
67184       {
67185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67186       };
67187     }
67188   }
67189 }
67190
67191
67192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
67193   void * jresult ;
67194   Dali::Path arg1 ;
67195   Dali::Vector3 *arg2 = 0 ;
67196   Dali::Property::Index arg3 ;
67197   Dali::Vector3 *arg4 = 0 ;
67198   unsigned int arg5 ;
67199   Dali::Path *argp1 ;
67200   Dali::Toolkit::ScrollViewPagePathEffect result;
67201
67202   argp1 = (Dali::Path *)jarg1;
67203   if (!argp1) {
67204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
67205     return 0;
67206   }
67207   arg1 = *argp1;
67208   arg2 = (Dali::Vector3 *)jarg2;
67209   if (!arg2) {
67210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67211     return 0;
67212   }
67213   arg3 = (Dali::Property::Index)jarg3;
67214   arg4 = (Dali::Vector3 *)jarg4;
67215   if (!arg4) {
67216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67217     return 0;
67218   }
67219   arg5 = (unsigned int)jarg5;
67220   {
67221     try {
67222       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
67223     } catch (std::out_of_range& e) {
67224       {
67225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67226       };
67227     } catch (std::exception& e) {
67228       {
67229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67230       };
67231     } catch (...) {
67232       {
67233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67234       };
67235     }
67236   }
67237   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67238   return jresult;
67239 }
67240
67241
67242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
67243   void * jresult ;
67244   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
67245
67246   {
67247     try {
67248       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
67249     } catch (std::out_of_range& e) {
67250       {
67251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67252       };
67253     } catch (std::exception& e) {
67254       {
67255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67256       };
67257     } catch (...) {
67258       {
67259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67260       };
67261     }
67262   }
67263   jresult = (void *)result;
67264   return jresult;
67265 }
67266
67267
67268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
67269   void * jresult ;
67270   Dali::BaseHandle arg1 ;
67271   Dali::BaseHandle *argp1 ;
67272   Dali::Toolkit::ScrollViewPagePathEffect result;
67273
67274   argp1 = (Dali::BaseHandle *)jarg1;
67275   if (!argp1) {
67276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67277     return 0;
67278   }
67279   arg1 = *argp1;
67280   {
67281     try {
67282       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
67283     } catch (std::out_of_range& e) {
67284       {
67285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67286       };
67287     } catch (std::exception& e) {
67288       {
67289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67290       };
67291     } catch (...) {
67292       {
67293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67294       };
67295     }
67296   }
67297   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67298   return jresult;
67299 }
67300
67301
67302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
67303   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67304   Dali::Actor arg2 ;
67305   unsigned int arg3 ;
67306   Dali::Actor *argp2 ;
67307
67308   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67309   argp2 = (Dali::Actor *)jarg2;
67310   if (!argp2) {
67311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67312     return ;
67313   }
67314   arg2 = *argp2;
67315   arg3 = (unsigned int)jarg3;
67316   {
67317     try {
67318       (arg1)->ApplyToPage(arg2,arg3);
67319     } catch (std::out_of_range& e) {
67320       {
67321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67322       };
67323     } catch (std::exception& e) {
67324       {
67325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67326       };
67327     } catch (...) {
67328       {
67329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67330       };
67331     }
67332   }
67333 }
67334
67335
67336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
67337   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67338
67339   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67340   {
67341     try {
67342       delete arg1;
67343     } catch (std::out_of_range& e) {
67344       {
67345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67346       };
67347     } catch (std::exception& e) {
67348       {
67349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67350       };
67351     } catch (...) {
67352       {
67353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67354       };
67355     }
67356   }
67357 }
67358
67359
67360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
67361   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67362   Dali::Toolkit::ClampState arg2 ;
67363
67364   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67365   arg2 = (Dali::Toolkit::ClampState)jarg2;
67366   if (arg1) (arg1)->x = arg2;
67367 }
67368
67369
67370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
67371   int jresult ;
67372   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67373   Dali::Toolkit::ClampState result;
67374
67375   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67376   result = (Dali::Toolkit::ClampState) ((arg1)->x);
67377   jresult = (int)result;
67378   return jresult;
67379 }
67380
67381
67382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
67383   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67384   Dali::Toolkit::ClampState arg2 ;
67385
67386   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67387   arg2 = (Dali::Toolkit::ClampState)jarg2;
67388   if (arg1) (arg1)->y = arg2;
67389 }
67390
67391
67392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
67393   int jresult ;
67394   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67395   Dali::Toolkit::ClampState result;
67396
67397   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67398   result = (Dali::Toolkit::ClampState) ((arg1)->y);
67399   jresult = (int)result;
67400   return jresult;
67401 }
67402
67403
67404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
67405   void * jresult ;
67406   Dali::Toolkit::ClampState2D *result = 0 ;
67407
67408   {
67409     try {
67410       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
67411     } catch (std::out_of_range& e) {
67412       {
67413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67414       };
67415     } catch (std::exception& e) {
67416       {
67417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67418       };
67419     } catch (...) {
67420       {
67421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67422       };
67423     }
67424   }
67425   jresult = (void *)result;
67426   return jresult;
67427 }
67428
67429
67430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
67431   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67432
67433   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67434   {
67435     try {
67436       delete arg1;
67437     } catch (std::out_of_range& e) {
67438       {
67439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67440       };
67441     } catch (std::exception& e) {
67442       {
67443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67444       };
67445     } catch (...) {
67446       {
67447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67448       };
67449     }
67450   }
67451 }
67452
67453
67454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
67455   void * jresult ;
67456   float arg1 ;
67457   float arg2 ;
67458   bool arg3 ;
67459   Dali::Toolkit::RulerDomain *result = 0 ;
67460
67461   arg1 = (float)jarg1;
67462   arg2 = (float)jarg2;
67463   arg3 = jarg3 ? true : false;
67464   {
67465     try {
67466       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
67467     } catch (std::out_of_range& e) {
67468       {
67469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67470       };
67471     } catch (std::exception& e) {
67472       {
67473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67474       };
67475     } catch (...) {
67476       {
67477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67478       };
67479     }
67480   }
67481   jresult = (void *)result;
67482   return jresult;
67483 }
67484
67485
67486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
67487   void * jresult ;
67488   float arg1 ;
67489   float arg2 ;
67490   Dali::Toolkit::RulerDomain *result = 0 ;
67491
67492   arg1 = (float)jarg1;
67493   arg2 = (float)jarg2;
67494   {
67495     try {
67496       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
67497     } catch (std::out_of_range& e) {
67498       {
67499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67500       };
67501     } catch (std::exception& e) {
67502       {
67503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67504       };
67505     } catch (...) {
67506       {
67507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67508       };
67509     }
67510   }
67511   jresult = (void *)result;
67512   return jresult;
67513 }
67514
67515
67516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
67517   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67518   float arg2 ;
67519
67520   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67521   arg2 = (float)jarg2;
67522   if (arg1) (arg1)->min = arg2;
67523 }
67524
67525
67526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
67527   float jresult ;
67528   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67529   float result;
67530
67531   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67532   result = (float) ((arg1)->min);
67533   jresult = result;
67534   return jresult;
67535 }
67536
67537
67538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
67539   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67540   float arg2 ;
67541
67542   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67543   arg2 = (float)jarg2;
67544   if (arg1) (arg1)->max = arg2;
67545 }
67546
67547
67548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
67549   float jresult ;
67550   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67551   float result;
67552
67553   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67554   result = (float) ((arg1)->max);
67555   jresult = result;
67556   return jresult;
67557 }
67558
67559
67560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
67561   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67562   bool arg2 ;
67563
67564   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67565   arg2 = jarg2 ? true : false;
67566   if (arg1) (arg1)->enabled = arg2;
67567 }
67568
67569
67570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
67571   unsigned int jresult ;
67572   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67573   bool result;
67574
67575   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67576   result = (bool) ((arg1)->enabled);
67577   jresult = result;
67578   return jresult;
67579 }
67580
67581
67582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67583   float jresult ;
67584   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67585   float arg2 ;
67586   float arg3 ;
67587   float arg4 ;
67588   float result;
67589
67590   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67591   arg2 = (float)jarg2;
67592   arg3 = (float)jarg3;
67593   arg4 = (float)jarg4;
67594   {
67595     try {
67596       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
67597     } catch (std::out_of_range& e) {
67598       {
67599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67600       };
67601     } catch (std::exception& e) {
67602       {
67603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67604       };
67605     } catch (...) {
67606       {
67607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67608       };
67609     }
67610   }
67611   jresult = result;
67612   return jresult;
67613 }
67614
67615
67616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67617   float jresult ;
67618   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67619   float arg2 ;
67620   float arg3 ;
67621   float result;
67622
67623   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67624   arg2 = (float)jarg2;
67625   arg3 = (float)jarg3;
67626   {
67627     try {
67628       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
67629     } catch (std::out_of_range& e) {
67630       {
67631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67632       };
67633     } catch (std::exception& e) {
67634       {
67635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67636       };
67637     } catch (...) {
67638       {
67639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67640       };
67641     }
67642   }
67643   jresult = result;
67644   return jresult;
67645 }
67646
67647
67648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
67649   float jresult ;
67650   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67651   float arg2 ;
67652   float result;
67653
67654   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67655   arg2 = (float)jarg2;
67656   {
67657     try {
67658       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
67659     } catch (std::out_of_range& e) {
67660       {
67661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67662       };
67663     } catch (std::exception& e) {
67664       {
67665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67666       };
67667     } catch (...) {
67668       {
67669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67670       };
67671     }
67672   }
67673   jresult = result;
67674   return jresult;
67675 }
67676
67677
67678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67679   float jresult ;
67680   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67681   float arg2 ;
67682   float arg3 ;
67683   float arg4 ;
67684   Dali::Toolkit::ClampState *arg5 = 0 ;
67685   float result;
67686
67687   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67688   arg2 = (float)jarg2;
67689   arg3 = (float)jarg3;
67690   arg4 = (float)jarg4;
67691   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67692   if (!arg5) {
67693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67694     return 0;
67695   }
67696   {
67697     try {
67698       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67699     } catch (std::out_of_range& e) {
67700       {
67701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67702       };
67703     } catch (std::exception& e) {
67704       {
67705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67706       };
67707     } catch (...) {
67708       {
67709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67710       };
67711     }
67712   }
67713   jresult = result;
67714   return jresult;
67715 }
67716
67717
67718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
67719   float jresult ;
67720   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67721   float result;
67722
67723   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67724   {
67725     try {
67726       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
67727     } catch (std::out_of_range& e) {
67728       {
67729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67730       };
67731     } catch (std::exception& e) {
67732       {
67733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67734       };
67735     } catch (...) {
67736       {
67737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67738       };
67739     }
67740   }
67741   jresult = result;
67742   return jresult;
67743 }
67744
67745
67746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
67747   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67748
67749   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67750   {
67751     try {
67752       delete arg1;
67753     } catch (std::out_of_range& e) {
67754       {
67755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67756       };
67757     } catch (std::exception& e) {
67758       {
67759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67760       };
67761     } catch (...) {
67762       {
67763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67764       };
67765     }
67766   }
67767 }
67768
67769
67770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
67771   float jresult ;
67772   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67773   float arg2 ;
67774   float arg3 ;
67775   float result;
67776
67777   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67778   arg2 = (float)jarg2;
67779   arg3 = (float)jarg3;
67780   {
67781     try {
67782       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
67783     } catch (std::out_of_range& e) {
67784       {
67785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67786       };
67787     } catch (std::exception& e) {
67788       {
67789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67790       };
67791     } catch (...) {
67792       {
67793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67794       };
67795     }
67796   }
67797   jresult = result;
67798   return jresult;
67799 }
67800
67801
67802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
67803   float jresult ;
67804   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67805   float arg2 ;
67806   float result;
67807
67808   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67809   arg2 = (float)jarg2;
67810   {
67811     try {
67812       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
67813     } catch (std::out_of_range& e) {
67814       {
67815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67816       };
67817     } catch (std::exception& e) {
67818       {
67819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67820       };
67821     } catch (...) {
67822       {
67823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67824       };
67825     }
67826   }
67827   jresult = result;
67828   return jresult;
67829 }
67830
67831
67832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
67833   float jresult ;
67834   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67835   unsigned int arg2 ;
67836   unsigned int *arg3 = 0 ;
67837   bool arg4 ;
67838   float result;
67839
67840   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67841   arg2 = (unsigned int)jarg2;
67842   arg3 = (unsigned int *)jarg3;
67843   arg4 = jarg4 ? true : false;
67844   {
67845     try {
67846       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
67847     } catch (std::out_of_range& e) {
67848       {
67849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67850       };
67851     } catch (std::exception& e) {
67852       {
67853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67854       };
67855     } catch (...) {
67856       {
67857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67858       };
67859     }
67860   }
67861   jresult = result;
67862   return jresult;
67863 }
67864
67865
67866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
67867   unsigned int jresult ;
67868   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67869   float arg2 ;
67870   bool arg3 ;
67871   unsigned int result;
67872
67873   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67874   arg2 = (float)jarg2;
67875   arg3 = jarg3 ? true : false;
67876   {
67877     try {
67878       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
67879     } catch (std::out_of_range& e) {
67880       {
67881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67882       };
67883     } catch (std::exception& e) {
67884       {
67885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67886       };
67887     } catch (...) {
67888       {
67889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67890       };
67891     }
67892   }
67893   jresult = result;
67894   return jresult;
67895 }
67896
67897
67898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
67899   unsigned int jresult ;
67900   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67901   unsigned int result;
67902
67903   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67904   {
67905     try {
67906       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
67907     } catch (std::out_of_range& e) {
67908       {
67909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67910       };
67911     } catch (std::exception& e) {
67912       {
67913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67914       };
67915     } catch (...) {
67916       {
67917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67918       };
67919     }
67920   }
67921   jresult = result;
67922   return jresult;
67923 }
67924
67925
67926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
67927   int jresult ;
67928   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67929   Dali::Toolkit::Ruler::RulerType result;
67930
67931   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67932   {
67933     try {
67934       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
67935     } catch (std::out_of_range& e) {
67936       {
67937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67938       };
67939     } catch (std::exception& e) {
67940       {
67941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67942       };
67943     } catch (...) {
67944       {
67945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67946       };
67947     }
67948   }
67949   jresult = (int)result;
67950   return jresult;
67951 }
67952
67953
67954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
67955   unsigned int jresult ;
67956   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67957   bool result;
67958
67959   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67960   {
67961     try {
67962       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
67963     } catch (std::out_of_range& e) {
67964       {
67965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67966       };
67967     } catch (std::exception& e) {
67968       {
67969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67970       };
67971     } catch (...) {
67972       {
67973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67974       };
67975     }
67976   }
67977   jresult = result;
67978   return jresult;
67979 }
67980
67981
67982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
67983   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67984
67985   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67986   {
67987     try {
67988       (arg1)->Enable();
67989     } catch (std::out_of_range& e) {
67990       {
67991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67992       };
67993     } catch (std::exception& e) {
67994       {
67995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67996       };
67997     } catch (...) {
67998       {
67999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68000       };
68001     }
68002   }
68003 }
68004
68005
68006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
68007   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68008
68009   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68010   {
68011     try {
68012       (arg1)->Disable();
68013     } catch (std::out_of_range& e) {
68014       {
68015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68016       };
68017     } catch (std::exception& e) {
68018       {
68019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68020       };
68021     } catch (...) {
68022       {
68023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68024       };
68025     }
68026   }
68027 }
68028
68029
68030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
68031   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68032   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
68033   Dali::Toolkit::RulerDomain *argp2 ;
68034
68035   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68036   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
68037   if (!argp2) {
68038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
68039     return ;
68040   }
68041   arg2 = *argp2;
68042   {
68043     try {
68044       (arg1)->SetDomain(arg2);
68045     } catch (std::out_of_range& e) {
68046       {
68047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68048       };
68049     } catch (std::exception& e) {
68050       {
68051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68052       };
68053     } catch (...) {
68054       {
68055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68056       };
68057     }
68058   }
68059 }
68060
68061
68062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
68063   void * jresult ;
68064   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68065   Dali::Toolkit::RulerDomain *result = 0 ;
68066
68067   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68068   {
68069     try {
68070       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
68071     } catch (std::out_of_range& e) {
68072       {
68073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68074       };
68075     } catch (std::exception& e) {
68076       {
68077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68078       };
68079     } catch (...) {
68080       {
68081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68082       };
68083     }
68084   }
68085   jresult = (void *)result;
68086   return jresult;
68087 }
68088
68089
68090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
68091   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68092
68093   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68094   {
68095     try {
68096       (arg1)->DisableDomain();
68097     } catch (std::out_of_range& e) {
68098       {
68099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68100       };
68101     } catch (std::exception& e) {
68102       {
68103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68104       };
68105     } catch (...) {
68106       {
68107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68108       };
68109     }
68110   }
68111 }
68112
68113
68114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
68115   float jresult ;
68116   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68117   float arg2 ;
68118   float arg3 ;
68119   float arg4 ;
68120   float result;
68121
68122   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68123   arg2 = (float)jarg2;
68124   arg3 = (float)jarg3;
68125   arg4 = (float)jarg4;
68126   {
68127     try {
68128       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
68129     } catch (std::out_of_range& e) {
68130       {
68131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68132       };
68133     } catch (std::exception& e) {
68134       {
68135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68136       };
68137     } catch (...) {
68138       {
68139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68140       };
68141     }
68142   }
68143   jresult = result;
68144   return jresult;
68145 }
68146
68147
68148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
68149   float jresult ;
68150   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68151   float arg2 ;
68152   float arg3 ;
68153   float result;
68154
68155   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68156   arg2 = (float)jarg2;
68157   arg3 = (float)jarg3;
68158   {
68159     try {
68160       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
68161     } catch (std::out_of_range& e) {
68162       {
68163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68164       };
68165     } catch (std::exception& e) {
68166       {
68167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68168       };
68169     } catch (...) {
68170       {
68171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68172       };
68173     }
68174   }
68175   jresult = result;
68176   return jresult;
68177 }
68178
68179
68180 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
68181   float jresult ;
68182   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68183   float arg2 ;
68184   float result;
68185
68186   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68187   arg2 = (float)jarg2;
68188   {
68189     try {
68190       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
68191     } catch (std::out_of_range& e) {
68192       {
68193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68194       };
68195     } catch (std::exception& e) {
68196       {
68197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68198       };
68199     } catch (...) {
68200       {
68201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68202       };
68203     }
68204   }
68205   jresult = result;
68206   return jresult;
68207 }
68208
68209
68210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
68211   float jresult ;
68212   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68213   float arg2 ;
68214   float arg3 ;
68215   float arg4 ;
68216   Dali::Toolkit::ClampState *arg5 = 0 ;
68217   float result;
68218
68219   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68220   arg2 = (float)jarg2;
68221   arg3 = (float)jarg3;
68222   arg4 = (float)jarg4;
68223   arg5 = (Dali::Toolkit::ClampState *)jarg5;
68224   if (!arg5) {
68225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68226     return 0;
68227   }
68228   {
68229     try {
68230       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
68231     } catch (std::out_of_range& e) {
68232       {
68233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68234       };
68235     } catch (std::exception& e) {
68236       {
68237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68238       };
68239     } catch (...) {
68240       {
68241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68242       };
68243     }
68244   }
68245   jresult = result;
68246   return jresult;
68247 }
68248
68249
68250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
68251   float jresult ;
68252   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68253   float arg2 ;
68254   float arg3 ;
68255   float arg4 ;
68256   float arg5 ;
68257   float result;
68258
68259   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68260   arg2 = (float)jarg2;
68261   arg3 = (float)jarg3;
68262   arg4 = (float)jarg4;
68263   arg5 = (float)jarg5;
68264   {
68265     try {
68266       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
68267     } catch (std::out_of_range& e) {
68268       {
68269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68270       };
68271     } catch (std::exception& e) {
68272       {
68273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68274       };
68275     } catch (...) {
68276       {
68277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68278       };
68279     }
68280   }
68281   jresult = result;
68282   return jresult;
68283 }
68284
68285
68286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
68287   float jresult ;
68288   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68289   float arg2 ;
68290   float arg3 ;
68291   float arg4 ;
68292   float result;
68293
68294   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68295   arg2 = (float)jarg2;
68296   arg3 = (float)jarg3;
68297   arg4 = (float)jarg4;
68298   {
68299     try {
68300       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
68301     } catch (std::out_of_range& e) {
68302       {
68303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68304       };
68305     } catch (std::exception& e) {
68306       {
68307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68308       };
68309     } catch (...) {
68310       {
68311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68312       };
68313     }
68314   }
68315   jresult = result;
68316   return jresult;
68317 }
68318
68319
68320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
68321   float jresult ;
68322   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68323   float arg2 ;
68324   float arg3 ;
68325   float result;
68326
68327   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68328   arg2 = (float)jarg2;
68329   arg3 = (float)jarg3;
68330   {
68331     try {
68332       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
68333     } catch (std::out_of_range& e) {
68334       {
68335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68336       };
68337     } catch (std::exception& e) {
68338       {
68339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68340       };
68341     } catch (...) {
68342       {
68343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68344       };
68345     }
68346   }
68347   jresult = result;
68348   return jresult;
68349 }
68350
68351
68352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
68353   float jresult ;
68354   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68355   float arg2 ;
68356   float result;
68357
68358   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68359   arg2 = (float)jarg2;
68360   {
68361     try {
68362       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
68363     } catch (std::out_of_range& e) {
68364       {
68365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68366       };
68367     } catch (std::exception& e) {
68368       {
68369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68370       };
68371     } catch (...) {
68372       {
68373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68374       };
68375     }
68376   }
68377   jresult = result;
68378   return jresult;
68379 }
68380
68381
68382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
68383   float jresult ;
68384   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68385   float arg2 ;
68386   float arg3 ;
68387   float arg4 ;
68388   float arg5 ;
68389   Dali::Toolkit::ClampState *arg6 = 0 ;
68390   float result;
68391
68392   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68393   arg2 = (float)jarg2;
68394   arg3 = (float)jarg3;
68395   arg4 = (float)jarg4;
68396   arg5 = (float)jarg5;
68397   arg6 = (Dali::Toolkit::ClampState *)jarg6;
68398   if (!arg6) {
68399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68400     return 0;
68401   }
68402   {
68403     try {
68404       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
68405     } catch (std::out_of_range& e) {
68406       {
68407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68408       };
68409     } catch (std::exception& e) {
68410       {
68411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68412       };
68413     } catch (...) {
68414       {
68415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68416       };
68417     }
68418   }
68419   jresult = result;
68420   return jresult;
68421 }
68422
68423
68424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
68425   void * jresult ;
68426   Dali::Toolkit::DefaultRuler *result = 0 ;
68427
68428   {
68429     try {
68430       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
68431     } catch (std::out_of_range& e) {
68432       {
68433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68434       };
68435     } catch (std::exception& e) {
68436       {
68437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68438       };
68439     } catch (...) {
68440       {
68441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68442       };
68443     }
68444   }
68445   jresult = (void *)result;
68446   return jresult;
68447 }
68448
68449
68450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68451   float jresult ;
68452   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68453   float arg2 ;
68454   float arg3 ;
68455   float result;
68456
68457   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68458   arg2 = (float)jarg2;
68459   arg3 = (float)jarg3;
68460   {
68461     try {
68462       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
68463     } catch (std::out_of_range& e) {
68464       {
68465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68466       };
68467     } catch (std::exception& e) {
68468       {
68469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68470       };
68471     } catch (...) {
68472       {
68473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68474       };
68475     }
68476   }
68477   jresult = result;
68478   return jresult;
68479 }
68480
68481
68482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68483   float jresult ;
68484   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68485   unsigned int arg2 ;
68486   unsigned int *arg3 = 0 ;
68487   bool arg4 ;
68488   float result;
68489
68490   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68491   arg2 = (unsigned int)jarg2;
68492   arg3 = (unsigned int *)jarg3;
68493   arg4 = jarg4 ? true : false;
68494   {
68495     try {
68496       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68497     } catch (std::out_of_range& e) {
68498       {
68499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68500       };
68501     } catch (std::exception& e) {
68502       {
68503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68504       };
68505     } catch (...) {
68506       {
68507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68508       };
68509     }
68510   }
68511   jresult = result;
68512   return jresult;
68513 }
68514
68515
68516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68517   unsigned int jresult ;
68518   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68519   float arg2 ;
68520   bool arg3 ;
68521   unsigned int result;
68522
68523   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68524   arg2 = (float)jarg2;
68525   arg3 = jarg3 ? true : false;
68526   {
68527     try {
68528       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68529     } catch (std::out_of_range& e) {
68530       {
68531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68532       };
68533     } catch (std::exception& e) {
68534       {
68535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68536       };
68537     } catch (...) {
68538       {
68539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68540       };
68541     }
68542   }
68543   jresult = result;
68544   return jresult;
68545 }
68546
68547
68548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
68549   unsigned int jresult ;
68550   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68551   unsigned int result;
68552
68553   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68554   {
68555     try {
68556       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
68557     } catch (std::out_of_range& e) {
68558       {
68559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68560       };
68561     } catch (std::exception& e) {
68562       {
68563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68564       };
68565     } catch (...) {
68566       {
68567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68568       };
68569     }
68570   }
68571   jresult = result;
68572   return jresult;
68573 }
68574
68575
68576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
68577   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68578
68579   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68580   {
68581     try {
68582       delete arg1;
68583     } catch (std::out_of_range& e) {
68584       {
68585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68586       };
68587     } catch (std::exception& e) {
68588       {
68589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68590       };
68591     } catch (...) {
68592       {
68593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68594       };
68595     }
68596   }
68597 }
68598
68599
68600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
68601   void * jresult ;
68602   float arg1 ;
68603   Dali::Toolkit::FixedRuler *result = 0 ;
68604
68605   arg1 = (float)jarg1;
68606   {
68607     try {
68608       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
68609     } catch (std::out_of_range& e) {
68610       {
68611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68612       };
68613     } catch (std::exception& e) {
68614       {
68615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68616       };
68617     } catch (...) {
68618       {
68619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68620       };
68621     }
68622   }
68623   jresult = (void *)result;
68624   return jresult;
68625 }
68626
68627
68628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
68629   void * jresult ;
68630   Dali::Toolkit::FixedRuler *result = 0 ;
68631
68632   {
68633     try {
68634       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
68635     } catch (std::out_of_range& e) {
68636       {
68637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68638       };
68639     } catch (std::exception& e) {
68640       {
68641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68642       };
68643     } catch (...) {
68644       {
68645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68646       };
68647     }
68648   }
68649   jresult = (void *)result;
68650   return jresult;
68651 }
68652
68653
68654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68655   float jresult ;
68656   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68657   float arg2 ;
68658   float arg3 ;
68659   float result;
68660
68661   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68662   arg2 = (float)jarg2;
68663   arg3 = (float)jarg3;
68664   {
68665     try {
68666       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
68667     } catch (std::out_of_range& e) {
68668       {
68669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68670       };
68671     } catch (std::exception& e) {
68672       {
68673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68674       };
68675     } catch (...) {
68676       {
68677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68678       };
68679     }
68680   }
68681   jresult = result;
68682   return jresult;
68683 }
68684
68685
68686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68687   float jresult ;
68688   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68689   unsigned int arg2 ;
68690   unsigned int *arg3 = 0 ;
68691   bool arg4 ;
68692   float result;
68693
68694   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68695   arg2 = (unsigned int)jarg2;
68696   arg3 = (unsigned int *)jarg3;
68697   arg4 = jarg4 ? true : false;
68698   {
68699     try {
68700       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68701     } catch (std::out_of_range& e) {
68702       {
68703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68704       };
68705     } catch (std::exception& e) {
68706       {
68707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68708       };
68709     } catch (...) {
68710       {
68711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68712       };
68713     }
68714   }
68715   jresult = result;
68716   return jresult;
68717 }
68718
68719
68720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68721   unsigned int jresult ;
68722   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68723   float arg2 ;
68724   bool arg3 ;
68725   unsigned int result;
68726
68727   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68728   arg2 = (float)jarg2;
68729   arg3 = jarg3 ? true : false;
68730   {
68731     try {
68732       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68733     } catch (std::out_of_range& e) {
68734       {
68735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68736       };
68737     } catch (std::exception& e) {
68738       {
68739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68740       };
68741     } catch (...) {
68742       {
68743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68744       };
68745     }
68746   }
68747   jresult = result;
68748   return jresult;
68749 }
68750
68751
68752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
68753   unsigned int jresult ;
68754   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68755   unsigned int result;
68756
68757   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68758   {
68759     try {
68760       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
68761     } catch (std::out_of_range& e) {
68762       {
68763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68764       };
68765     } catch (std::exception& e) {
68766       {
68767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68768       };
68769     } catch (...) {
68770       {
68771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68772       };
68773     }
68774   }
68775   jresult = result;
68776   return jresult;
68777 }
68778
68779
68780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
68781   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68782
68783   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68784   {
68785     try {
68786       delete arg1;
68787     } catch (std::out_of_range& e) {
68788       {
68789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68790       };
68791     } catch (std::exception& e) {
68792       {
68793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68794       };
68795     } catch (...) {
68796       {
68797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68798       };
68799     }
68800   }
68801 }
68802
68803
68804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
68805   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68806   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68807
68808   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68809   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68810   if (arg1) (arg1)->scale = *arg2;
68811 }
68812
68813
68814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
68815   void * jresult ;
68816   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68817   Dali::Toolkit::ClampState2D *result = 0 ;
68818
68819   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68820   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
68821   jresult = (void *)result;
68822   return jresult;
68823 }
68824
68825
68826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
68827   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68828   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68829
68830   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68831   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68832   if (arg1) (arg1)->position = *arg2;
68833 }
68834
68835
68836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
68837   void * jresult ;
68838   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68839   Dali::Toolkit::ClampState2D *result = 0 ;
68840
68841   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68842   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
68843   jresult = (void *)result;
68844   return jresult;
68845 }
68846
68847
68848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
68849   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68850   Dali::Toolkit::ClampState arg2 ;
68851
68852   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68853   arg2 = (Dali::Toolkit::ClampState)jarg2;
68854   if (arg1) (arg1)->rotation = arg2;
68855 }
68856
68857
68858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
68859   int jresult ;
68860   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68861   Dali::Toolkit::ClampState result;
68862
68863   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68864   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
68865   jresult = (int)result;
68866   return jresult;
68867 }
68868
68869
68870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
68871   void * jresult ;
68872   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
68873
68874   {
68875     try {
68876       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
68877     } catch (std::out_of_range& e) {
68878       {
68879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68880       };
68881     } catch (std::exception& e) {
68882       {
68883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68884       };
68885     } catch (...) {
68886       {
68887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68888       };
68889     }
68890   }
68891   jresult = (void *)result;
68892   return jresult;
68893 }
68894
68895
68896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
68897   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68898
68899   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68900   {
68901     try {
68902       delete arg1;
68903     } catch (std::out_of_range& e) {
68904       {
68905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68906       };
68907     } catch (std::exception& e) {
68908       {
68909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68910       };
68911     } catch (...) {
68912       {
68913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68914       };
68915     }
68916   }
68917 }
68918
68919
68920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
68921   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68922   Dali::Toolkit::SnapType arg2 ;
68923
68924   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68925   arg2 = (Dali::Toolkit::SnapType)jarg2;
68926   if (arg1) (arg1)->type = arg2;
68927 }
68928
68929
68930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
68931   int jresult ;
68932   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68933   Dali::Toolkit::SnapType result;
68934
68935   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68936   result = (Dali::Toolkit::SnapType) ((arg1)->type);
68937   jresult = (int)result;
68938   return jresult;
68939 }
68940
68941
68942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
68943   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68944   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
68945
68946   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68947   arg2 = (Dali::Vector2 *)jarg2;
68948   if (arg1) (arg1)->position = *arg2;
68949 }
68950
68951
68952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
68953   void * jresult ;
68954   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68955   Dali::Vector2 *result = 0 ;
68956
68957   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68958   result = (Dali::Vector2 *)& ((arg1)->position);
68959   jresult = (void *)result;
68960   return jresult;
68961 }
68962
68963
68964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
68965   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68966   float arg2 ;
68967
68968   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68969   arg2 = (float)jarg2;
68970   if (arg1) (arg1)->duration = arg2;
68971 }
68972
68973
68974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
68975   float jresult ;
68976   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68977   float result;
68978
68979   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68980   result = (float) ((arg1)->duration);
68981   jresult = result;
68982   return jresult;
68983 }
68984
68985
68986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
68987   void * jresult ;
68988   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
68989
68990   {
68991     try {
68992       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
68993     } catch (std::out_of_range& e) {
68994       {
68995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68996       };
68997     } catch (std::exception& e) {
68998       {
68999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69000       };
69001     } catch (...) {
69002       {
69003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69004       };
69005     }
69006   }
69007   jresult = (void *)result;
69008   return jresult;
69009 }
69010
69011
69012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
69013   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
69014
69015   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
69016   {
69017     try {
69018       delete arg1;
69019     } catch (std::out_of_range& e) {
69020       {
69021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69022       };
69023     } catch (std::exception& e) {
69024       {
69025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69026       };
69027     } catch (...) {
69028       {
69029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69030       };
69031     }
69032   }
69033 }
69034
69035
69036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
69037   int jresult ;
69038   int result;
69039
69040   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
69041   jresult = (int)result;
69042   return jresult;
69043 }
69044
69045
69046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
69047   int jresult ;
69048   int result;
69049
69050   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
69051   jresult = (int)result;
69052   return jresult;
69053 }
69054
69055
69056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
69057   int jresult ;
69058   int result;
69059
69060   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
69061   jresult = (int)result;
69062   return jresult;
69063 }
69064
69065
69066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69067   int jresult ;
69068   int result;
69069
69070   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69071   jresult = (int)result;
69072   return jresult;
69073 }
69074
69075
69076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
69077   int jresult ;
69078   int result;
69079
69080   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
69081   jresult = (int)result;
69082   return jresult;
69083 }
69084
69085
69086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
69087   int jresult ;
69088   int result;
69089
69090   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
69091   jresult = (int)result;
69092   return jresult;
69093 }
69094
69095
69096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
69097   int jresult ;
69098   int result;
69099
69100   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
69101   jresult = (int)result;
69102   return jresult;
69103 }
69104
69105
69106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
69107   int jresult ;
69108   int result;
69109
69110   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
69111   jresult = (int)result;
69112   return jresult;
69113 }
69114
69115
69116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
69117   int jresult ;
69118   int result;
69119
69120   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
69121   jresult = (int)result;
69122   return jresult;
69123 }
69124
69125
69126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
69127   int jresult ;
69128   int result;
69129
69130   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
69131   jresult = (int)result;
69132   return jresult;
69133 }
69134
69135
69136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
69137   int jresult ;
69138   int result;
69139
69140   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
69141   jresult = (int)result;
69142   return jresult;
69143 }
69144
69145
69146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
69147   int jresult ;
69148   int result;
69149
69150   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
69151   jresult = (int)result;
69152   return jresult;
69153 }
69154
69155
69156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
69157   int jresult ;
69158   int result;
69159
69160   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
69161   jresult = (int)result;
69162   return jresult;
69163 }
69164
69165
69166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
69167   int jresult ;
69168   int result;
69169
69170   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
69171   jresult = (int)result;
69172   return jresult;
69173 }
69174
69175
69176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
69177   int jresult ;
69178   int result;
69179
69180   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
69181   jresult = (int)result;
69182   return jresult;
69183 }
69184
69185
69186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
69187   int jresult ;
69188   int result;
69189
69190   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
69191   jresult = (int)result;
69192   return jresult;
69193 }
69194
69195
69196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
69197   int jresult ;
69198   int result;
69199
69200   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
69201   jresult = (int)result;
69202   return jresult;
69203 }
69204
69205
69206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
69207   int jresult ;
69208   int result;
69209
69210   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
69211   jresult = (int)result;
69212   return jresult;
69213 }
69214
69215
69216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
69217   int jresult ;
69218   int result;
69219
69220   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
69221   jresult = (int)result;
69222   return jresult;
69223 }
69224
69225
69226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
69227   int jresult ;
69228   int result;
69229
69230   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
69231   jresult = (int)result;
69232   return jresult;
69233 }
69234
69235
69236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
69237   int jresult ;
69238   int result;
69239
69240   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
69241   jresult = (int)result;
69242   return jresult;
69243 }
69244
69245
69246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
69247   int jresult ;
69248   int result;
69249
69250   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
69251   jresult = (int)result;
69252   return jresult;
69253 }
69254
69255
69256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
69257   int jresult ;
69258   int result;
69259
69260   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
69261   jresult = (int)result;
69262   return jresult;
69263 }
69264
69265
69266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
69267   int jresult ;
69268   int result;
69269
69270   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
69271   jresult = (int)result;
69272   return jresult;
69273 }
69274
69275
69276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
69277   int jresult ;
69278   int result;
69279
69280   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
69281   jresult = (int)result;
69282   return jresult;
69283 }
69284
69285
69286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
69287   void * jresult ;
69288   Dali::Toolkit::ScrollView::Property *result = 0 ;
69289
69290   {
69291     try {
69292       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
69293     } catch (std::out_of_range& e) {
69294       {
69295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69296       };
69297     } catch (std::exception& e) {
69298       {
69299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69300       };
69301     } catch (...) {
69302       {
69303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69304       };
69305     }
69306   }
69307   jresult = (void *)result;
69308   return jresult;
69309 }
69310
69311
69312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
69313   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
69314
69315   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
69316   {
69317     try {
69318       delete arg1;
69319     } catch (std::out_of_range& e) {
69320       {
69321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69322       };
69323     } catch (std::exception& e) {
69324       {
69325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69326       };
69327     } catch (...) {
69328       {
69329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69330       };
69331     }
69332   }
69333 }
69334
69335
69336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
69337   void * jresult ;
69338   Dali::Toolkit::ScrollView *result = 0 ;
69339
69340   {
69341     try {
69342       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
69343     } catch (std::out_of_range& e) {
69344       {
69345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69346       };
69347     } catch (std::exception& e) {
69348       {
69349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69350       };
69351     } catch (...) {
69352       {
69353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69354       };
69355     }
69356   }
69357   jresult = (void *)result;
69358   return jresult;
69359 }
69360
69361
69362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
69363   void * jresult ;
69364   Dali::Toolkit::ScrollView *arg1 = 0 ;
69365   Dali::Toolkit::ScrollView *result = 0 ;
69366
69367   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69368   if (!arg1) {
69369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69370     return 0;
69371   }
69372   {
69373     try {
69374       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
69375     } catch (std::out_of_range& e) {
69376       {
69377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69378       };
69379     } catch (std::exception& e) {
69380       {
69381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69382       };
69383     } catch (...) {
69384       {
69385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69386       };
69387     }
69388   }
69389   jresult = (void *)result;
69390   return jresult;
69391 }
69392
69393
69394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
69395   void * jresult ;
69396   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69397   Dali::Toolkit::ScrollView *arg2 = 0 ;
69398   Dali::Toolkit::ScrollView *result = 0 ;
69399
69400   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69401   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
69402   if (!arg2) {
69403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69404     return 0;
69405   }
69406   {
69407     try {
69408       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
69409     } catch (std::out_of_range& e) {
69410       {
69411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69412       };
69413     } catch (std::exception& e) {
69414       {
69415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69416       };
69417     } catch (...) {
69418       {
69419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69420       };
69421     }
69422   }
69423   jresult = (void *)result;
69424   return jresult;
69425 }
69426
69427
69428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
69429   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69430
69431   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69432   {
69433     try {
69434       delete arg1;
69435     } catch (std::out_of_range& e) {
69436       {
69437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69438       };
69439     } catch (std::exception& e) {
69440       {
69441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69442       };
69443     } catch (...) {
69444       {
69445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69446       };
69447     }
69448   }
69449 }
69450
69451
69452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
69453   void * jresult ;
69454   Dali::Toolkit::ScrollView result;
69455
69456   {
69457     try {
69458       result = Dali::Toolkit::ScrollView::New();
69459     } catch (std::out_of_range& e) {
69460       {
69461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69462       };
69463     } catch (std::exception& e) {
69464       {
69465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69466       };
69467     } catch (...) {
69468       {
69469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69470       };
69471     }
69472   }
69473   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69474   return jresult;
69475 }
69476
69477
69478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
69479   void * jresult ;
69480   Dali::BaseHandle arg1 ;
69481   Dali::BaseHandle *argp1 ;
69482   Dali::Toolkit::ScrollView result;
69483
69484   argp1 = (Dali::BaseHandle *)jarg1;
69485   if (!argp1) {
69486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69487     return 0;
69488   }
69489   arg1 = *argp1;
69490   {
69491     try {
69492       result = Dali::Toolkit::ScrollView::DownCast(arg1);
69493     } catch (std::out_of_range& e) {
69494       {
69495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69496       };
69497     } catch (std::exception& e) {
69498       {
69499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69500       };
69501     } catch (...) {
69502       {
69503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69504       };
69505     }
69506   }
69507   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69508   return jresult;
69509 }
69510
69511
69512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
69513   void * jresult ;
69514   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69515   Dali::AlphaFunction result;
69516
69517   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69518   {
69519     try {
69520       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
69521     } catch (std::out_of_range& e) {
69522       {
69523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69524       };
69525     } catch (std::exception& e) {
69526       {
69527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69528       };
69529     } catch (...) {
69530       {
69531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69532       };
69533     }
69534   }
69535   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69536   return jresult;
69537 }
69538
69539
69540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
69541   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69542   Dali::AlphaFunction arg2 ;
69543   Dali::AlphaFunction *argp2 ;
69544
69545   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69546   argp2 = (Dali::AlphaFunction *)jarg2;
69547   if (!argp2) {
69548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69549     return ;
69550   }
69551   arg2 = *argp2;
69552   {
69553     try {
69554       (arg1)->SetScrollSnapAlphaFunction(arg2);
69555     } catch (std::out_of_range& e) {
69556       {
69557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69558       };
69559     } catch (std::exception& e) {
69560       {
69561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69562       };
69563     } catch (...) {
69564       {
69565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69566       };
69567     }
69568   }
69569 }
69570
69571
69572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
69573   void * jresult ;
69574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69575   Dali::AlphaFunction result;
69576
69577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69578   {
69579     try {
69580       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
69581     } catch (std::out_of_range& e) {
69582       {
69583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69584       };
69585     } catch (std::exception& e) {
69586       {
69587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69588       };
69589     } catch (...) {
69590       {
69591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69592       };
69593     }
69594   }
69595   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69596   return jresult;
69597 }
69598
69599
69600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
69601   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69602   Dali::AlphaFunction arg2 ;
69603   Dali::AlphaFunction *argp2 ;
69604
69605   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69606   argp2 = (Dali::AlphaFunction *)jarg2;
69607   if (!argp2) {
69608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69609     return ;
69610   }
69611   arg2 = *argp2;
69612   {
69613     try {
69614       (arg1)->SetScrollFlickAlphaFunction(arg2);
69615     } catch (std::out_of_range& e) {
69616       {
69617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69618       };
69619     } catch (std::exception& e) {
69620       {
69621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69622       };
69623     } catch (...) {
69624       {
69625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69626       };
69627     }
69628   }
69629 }
69630
69631
69632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
69633   float jresult ;
69634   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69635   float result;
69636
69637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69638   {
69639     try {
69640       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
69641     } catch (std::out_of_range& e) {
69642       {
69643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69644       };
69645     } catch (std::exception& e) {
69646       {
69647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69648       };
69649     } catch (...) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69652       };
69653     }
69654   }
69655   jresult = result;
69656   return jresult;
69657 }
69658
69659
69660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
69661   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69662   float arg2 ;
69663
69664   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69665   arg2 = (float)jarg2;
69666   {
69667     try {
69668       (arg1)->SetScrollSnapDuration(arg2);
69669     } catch (std::out_of_range& e) {
69670       {
69671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69672       };
69673     } catch (std::exception& e) {
69674       {
69675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69676       };
69677     } catch (...) {
69678       {
69679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69680       };
69681     }
69682   }
69683 }
69684
69685
69686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
69687   float jresult ;
69688   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69689   float result;
69690
69691   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69692   {
69693     try {
69694       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
69695     } catch (std::out_of_range& e) {
69696       {
69697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69698       };
69699     } catch (std::exception& e) {
69700       {
69701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69702       };
69703     } catch (...) {
69704       {
69705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69706       };
69707     }
69708   }
69709   jresult = result;
69710   return jresult;
69711 }
69712
69713
69714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
69715   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69716   float arg2 ;
69717
69718   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69719   arg2 = (float)jarg2;
69720   {
69721     try {
69722       (arg1)->SetScrollFlickDuration(arg2);
69723     } catch (std::out_of_range& e) {
69724       {
69725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69726       };
69727     } catch (std::exception& e) {
69728       {
69729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69730       };
69731     } catch (...) {
69732       {
69733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69734       };
69735     }
69736   }
69737 }
69738
69739
69740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
69741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69742   Dali::Toolkit::RulerPtr arg2 ;
69743   Dali::Toolkit::RulerPtr *argp2 ;
69744
69745   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69746   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69747   if (!argp2) {
69748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69749     return ;
69750   }
69751   arg2 = *argp2;
69752   {
69753     try {
69754       (arg1)->SetRulerX(arg2);
69755     } catch (std::out_of_range& e) {
69756       {
69757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69758       };
69759     } catch (std::exception& e) {
69760       {
69761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69762       };
69763     } catch (...) {
69764       {
69765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69766       };
69767     }
69768   }
69769 }
69770
69771
69772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
69773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69774   Dali::Toolkit::RulerPtr arg2 ;
69775   Dali::Toolkit::RulerPtr *argp2 ;
69776
69777   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69778   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69779   if (!argp2) {
69780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69781     return ;
69782   }
69783   arg2 = *argp2;
69784   {
69785     try {
69786       (arg1)->SetRulerY(arg2);
69787     } catch (std::out_of_range& e) {
69788       {
69789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69790       };
69791     } catch (std::exception& e) {
69792       {
69793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69794       };
69795     } catch (...) {
69796       {
69797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69798       };
69799     }
69800   }
69801 }
69802
69803
69804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
69805   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69806   bool arg2 ;
69807
69808   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69809   arg2 = jarg2 ? true : false;
69810   {
69811     try {
69812       (arg1)->SetScrollSensitive(arg2);
69813     } catch (std::out_of_range& e) {
69814       {
69815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69816       };
69817     } catch (std::exception& e) {
69818       {
69819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69820       };
69821     } catch (...) {
69822       {
69823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69824       };
69825     }
69826   }
69827 }
69828
69829
69830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
69831   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69832   float arg2 ;
69833   float arg3 ;
69834
69835   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69836   arg2 = (float)jarg2;
69837   arg3 = (float)jarg3;
69838   {
69839     try {
69840       (arg1)->SetMaxOvershoot(arg2,arg3);
69841     } catch (std::out_of_range& e) {
69842       {
69843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69844       };
69845     } catch (std::exception& e) {
69846       {
69847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69848       };
69849     } catch (...) {
69850       {
69851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69852       };
69853     }
69854   }
69855 }
69856
69857
69858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
69859   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69860   Dali::AlphaFunction arg2 ;
69861   Dali::AlphaFunction *argp2 ;
69862
69863   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69864   argp2 = (Dali::AlphaFunction *)jarg2;
69865   if (!argp2) {
69866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69867     return ;
69868   }
69869   arg2 = *argp2;
69870   {
69871     try {
69872       (arg1)->SetSnapOvershootAlphaFunction(arg2);
69873     } catch (std::out_of_range& e) {
69874       {
69875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69876       };
69877     } catch (std::exception& e) {
69878       {
69879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69880       };
69881     } catch (...) {
69882       {
69883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69884       };
69885     }
69886   }
69887 }
69888
69889
69890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
69891   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69892   float arg2 ;
69893
69894   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69895   arg2 = (float)jarg2;
69896   {
69897     try {
69898       (arg1)->SetSnapOvershootDuration(arg2);
69899     } catch (std::out_of_range& e) {
69900       {
69901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69902       };
69903     } catch (std::exception& e) {
69904       {
69905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69906       };
69907     } catch (...) {
69908       {
69909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69910       };
69911     }
69912   }
69913 }
69914
69915
69916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
69917   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69918   bool arg2 ;
69919
69920   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69921   arg2 = jarg2 ? true : false;
69922   {
69923     try {
69924       (arg1)->SetActorAutoSnap(arg2);
69925     } catch (std::out_of_range& e) {
69926       {
69927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69928       };
69929     } catch (std::exception& e) {
69930       {
69931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69932       };
69933     } catch (...) {
69934       {
69935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69936       };
69937     }
69938   }
69939 }
69940
69941
69942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
69943   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69944   bool arg2 ;
69945
69946   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69947   arg2 = jarg2 ? true : false;
69948   {
69949     try {
69950       (arg1)->SetWrapMode(arg2);
69951     } catch (std::out_of_range& e) {
69952       {
69953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69954       };
69955     } catch (std::exception& e) {
69956       {
69957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69958       };
69959     } catch (...) {
69960       {
69961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69962       };
69963     }
69964   }
69965 }
69966
69967
69968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
69969   int jresult ;
69970   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69971   int result;
69972
69973   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69974   {
69975     try {
69976       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
69977     } catch (std::out_of_range& e) {
69978       {
69979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69980       };
69981     } catch (std::exception& e) {
69982       {
69983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69984       };
69985     } catch (...) {
69986       {
69987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69988       };
69989     }
69990   }
69991   jresult = result;
69992   return jresult;
69993 }
69994
69995
69996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
69997   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69998   int arg2 ;
69999
70000   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70001   arg2 = (int)jarg2;
70002   {
70003     try {
70004       (arg1)->SetScrollUpdateDistance(arg2);
70005     } catch (std::out_of_range& e) {
70006       {
70007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70008       };
70009     } catch (std::exception& e) {
70010       {
70011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70012       };
70013     } catch (...) {
70014       {
70015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70016       };
70017     }
70018   }
70019 }
70020
70021
70022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
70023   unsigned int jresult ;
70024   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70025   bool result;
70026
70027   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70028   {
70029     try {
70030       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
70031     } catch (std::out_of_range& e) {
70032       {
70033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70034       };
70035     } catch (std::exception& e) {
70036       {
70037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70038       };
70039     } catch (...) {
70040       {
70041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70042       };
70043     }
70044   }
70045   jresult = result;
70046   return jresult;
70047 }
70048
70049
70050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
70051   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70052   bool arg2 ;
70053
70054   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70055   arg2 = jarg2 ? true : false;
70056   {
70057     try {
70058       (arg1)->SetAxisAutoLock(arg2);
70059     } catch (std::out_of_range& e) {
70060       {
70061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70062       };
70063     } catch (std::exception& e) {
70064       {
70065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70066       };
70067     } catch (...) {
70068       {
70069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70070       };
70071     }
70072   }
70073 }
70074
70075
70076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
70077   float jresult ;
70078   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70079   float result;
70080
70081   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70082   {
70083     try {
70084       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
70085     } catch (std::out_of_range& e) {
70086       {
70087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70088       };
70089     } catch (std::exception& e) {
70090       {
70091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70092       };
70093     } catch (...) {
70094       {
70095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70096       };
70097     }
70098   }
70099   jresult = result;
70100   return jresult;
70101 }
70102
70103
70104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
70105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70106   float arg2 ;
70107
70108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70109   arg2 = (float)jarg2;
70110   {
70111     try {
70112       (arg1)->SetAxisAutoLockGradient(arg2);
70113     } catch (std::out_of_range& e) {
70114       {
70115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70116       };
70117     } catch (std::exception& e) {
70118       {
70119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70120       };
70121     } catch (...) {
70122       {
70123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70124       };
70125     }
70126   }
70127 }
70128
70129
70130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
70131   float jresult ;
70132   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70133   float result;
70134
70135   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70136   {
70137     try {
70138       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
70139     } catch (std::out_of_range& e) {
70140       {
70141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70142       };
70143     } catch (std::exception& e) {
70144       {
70145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70146       };
70147     } catch (...) {
70148       {
70149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70150       };
70151     }
70152   }
70153   jresult = result;
70154   return jresult;
70155 }
70156
70157
70158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
70159   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70160   float arg2 ;
70161
70162   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70163   arg2 = (float)jarg2;
70164   {
70165     try {
70166       (arg1)->SetFrictionCoefficient(arg2);
70167     } catch (std::out_of_range& e) {
70168       {
70169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70170       };
70171     } catch (std::exception& e) {
70172       {
70173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70174       };
70175     } catch (...) {
70176       {
70177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70178       };
70179     }
70180   }
70181 }
70182
70183
70184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
70185   float jresult ;
70186   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70187   float result;
70188
70189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70190   {
70191     try {
70192       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
70193     } catch (std::out_of_range& e) {
70194       {
70195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70196       };
70197     } catch (std::exception& e) {
70198       {
70199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70200       };
70201     } catch (...) {
70202       {
70203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70204       };
70205     }
70206   }
70207   jresult = result;
70208   return jresult;
70209 }
70210
70211
70212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
70213   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70214   float arg2 ;
70215
70216   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70217   arg2 = (float)jarg2;
70218   {
70219     try {
70220       (arg1)->SetFlickSpeedCoefficient(arg2);
70221     } catch (std::out_of_range& e) {
70222       {
70223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70224       };
70225     } catch (std::exception& e) {
70226       {
70227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70228       };
70229     } catch (...) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70232       };
70233     }
70234   }
70235 }
70236
70237
70238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
70239   void * jresult ;
70240   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70241   Dali::Vector2 result;
70242
70243   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70244   {
70245     try {
70246       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
70247     } catch (std::out_of_range& e) {
70248       {
70249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70250       };
70251     } catch (std::exception& e) {
70252       {
70253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70254       };
70255     } catch (...) {
70256       {
70257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70258       };
70259     }
70260   }
70261   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70262   return jresult;
70263 }
70264
70265
70266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
70267   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70268   Dali::Vector2 *arg2 = 0 ;
70269
70270   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70271   arg2 = (Dali::Vector2 *)jarg2;
70272   if (!arg2) {
70273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70274     return ;
70275   }
70276   {
70277     try {
70278       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
70279     } catch (std::out_of_range& e) {
70280       {
70281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70282       };
70283     } catch (std::exception& e) {
70284       {
70285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70286       };
70287     } catch (...) {
70288       {
70289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70290       };
70291     }
70292   }
70293 }
70294
70295
70296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
70297   float jresult ;
70298   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70299   float result;
70300
70301   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70302   {
70303     try {
70304       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
70305     } catch (std::out_of_range& e) {
70306       {
70307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70308       };
70309     } catch (std::exception& e) {
70310       {
70311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70312       };
70313     } catch (...) {
70314       {
70315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70316       };
70317     }
70318   }
70319   jresult = result;
70320   return jresult;
70321 }
70322
70323
70324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
70325   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70326   float arg2 ;
70327
70328   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70329   arg2 = (float)jarg2;
70330   {
70331     try {
70332       (arg1)->SetMinimumSpeedForFlick(arg2);
70333     } catch (std::out_of_range& e) {
70334       {
70335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70336       };
70337     } catch (std::exception& e) {
70338       {
70339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70340       };
70341     } catch (...) {
70342       {
70343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70344       };
70345     }
70346   }
70347 }
70348
70349
70350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
70351   float jresult ;
70352   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70353   float result;
70354
70355   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70356   {
70357     try {
70358       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
70359     } catch (std::out_of_range& e) {
70360       {
70361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70362       };
70363     } catch (std::exception& e) {
70364       {
70365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70366       };
70367     } catch (...) {
70368       {
70369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70370       };
70371     }
70372   }
70373   jresult = result;
70374   return jresult;
70375 }
70376
70377
70378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
70379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70380   float arg2 ;
70381
70382   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70383   arg2 = (float)jarg2;
70384   {
70385     try {
70386       (arg1)->SetMaxFlickSpeed(arg2);
70387     } catch (std::out_of_range& e) {
70388       {
70389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70390       };
70391     } catch (std::exception& e) {
70392       {
70393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70394       };
70395     } catch (...) {
70396       {
70397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70398       };
70399     }
70400   }
70401 }
70402
70403
70404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
70405   void * jresult ;
70406   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70407   Dali::Vector2 result;
70408
70409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70410   {
70411     try {
70412       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
70413     } catch (std::out_of_range& e) {
70414       {
70415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70416       };
70417     } catch (std::exception& e) {
70418       {
70419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70420       };
70421     } catch (...) {
70422       {
70423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70424       };
70425     }
70426   }
70427   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70428   return jresult;
70429 }
70430
70431
70432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
70433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70434   Dali::Vector2 arg2 ;
70435   Dali::Vector2 *argp2 ;
70436
70437   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70438   argp2 = (Dali::Vector2 *)jarg2;
70439   if (!argp2) {
70440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
70441     return ;
70442   }
70443   arg2 = *argp2;
70444   {
70445     try {
70446       (arg1)->SetWheelScrollDistanceStep(arg2);
70447     } catch (std::out_of_range& e) {
70448       {
70449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70450       };
70451     } catch (std::exception& e) {
70452       {
70453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70454       };
70455     } catch (...) {
70456       {
70457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70458       };
70459     }
70460   }
70461 }
70462
70463
70464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
70465   void * jresult ;
70466   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70467   Dali::Vector2 result;
70468
70469   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70470   {
70471     try {
70472       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
70473     } catch (std::out_of_range& e) {
70474       {
70475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70476       };
70477     } catch (std::exception& e) {
70478       {
70479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70480       };
70481     } catch (...) {
70482       {
70483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70484       };
70485     }
70486   }
70487   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70488   return jresult;
70489 }
70490
70491
70492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
70493   unsigned int jresult ;
70494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70495   unsigned int result;
70496
70497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70498   {
70499     try {
70500       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
70501     } catch (std::out_of_range& e) {
70502       {
70503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70504       };
70505     } catch (std::exception& e) {
70506       {
70507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70508       };
70509     } catch (...) {
70510       {
70511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70512       };
70513     }
70514   }
70515   jresult = result;
70516   return jresult;
70517 }
70518
70519
70520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
70521   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70522   Dali::Vector2 *arg2 = 0 ;
70523
70524   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70525   arg2 = (Dali::Vector2 *)jarg2;
70526   if (!arg2) {
70527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70528     return ;
70529   }
70530   {
70531     try {
70532       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
70533     } catch (std::out_of_range& e) {
70534       {
70535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70536       };
70537     } catch (std::exception& e) {
70538       {
70539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70540       };
70541     } catch (...) {
70542       {
70543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70544       };
70545     }
70546   }
70547 }
70548
70549
70550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
70551   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70552   Dali::Vector2 *arg2 = 0 ;
70553   float arg3 ;
70554
70555   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70556   arg2 = (Dali::Vector2 *)jarg2;
70557   if (!arg2) {
70558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70559     return ;
70560   }
70561   arg3 = (float)jarg3;
70562   {
70563     try {
70564       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
70565     } catch (std::out_of_range& e) {
70566       {
70567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70568       };
70569     } catch (std::exception& e) {
70570       {
70571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70572       };
70573     } catch (...) {
70574       {
70575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70576       };
70577     }
70578   }
70579 }
70580
70581
70582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
70583   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70584   Dali::Vector2 *arg2 = 0 ;
70585   float arg3 ;
70586   Dali::AlphaFunction arg4 ;
70587   Dali::AlphaFunction *argp4 ;
70588
70589   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70590   arg2 = (Dali::Vector2 *)jarg2;
70591   if (!arg2) {
70592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70593     return ;
70594   }
70595   arg3 = (float)jarg3;
70596   argp4 = (Dali::AlphaFunction *)jarg4;
70597   if (!argp4) {
70598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70599     return ;
70600   }
70601   arg4 = *argp4;
70602   {
70603     try {
70604       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
70605     } catch (std::out_of_range& e) {
70606       {
70607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70608       };
70609     } catch (std::exception& e) {
70610       {
70611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70612       };
70613     } catch (...) {
70614       {
70615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70616       };
70617     }
70618   }
70619 }
70620
70621
70622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
70623   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70624   Dali::Vector2 *arg2 = 0 ;
70625   float arg3 ;
70626   Dali::Toolkit::DirectionBias arg4 ;
70627   Dali::Toolkit::DirectionBias arg5 ;
70628
70629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70630   arg2 = (Dali::Vector2 *)jarg2;
70631   if (!arg2) {
70632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70633     return ;
70634   }
70635   arg3 = (float)jarg3;
70636   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70637   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70638   {
70639     try {
70640       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
70641     } catch (std::out_of_range& e) {
70642       {
70643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70644       };
70645     } catch (std::exception& e) {
70646       {
70647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70648       };
70649     } catch (...) {
70650       {
70651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70652       };
70653     }
70654   }
70655 }
70656
70657
70658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
70659   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70660   Dali::Vector2 *arg2 = 0 ;
70661   float arg3 ;
70662   Dali::AlphaFunction arg4 ;
70663   Dali::Toolkit::DirectionBias arg5 ;
70664   Dali::Toolkit::DirectionBias arg6 ;
70665   Dali::AlphaFunction *argp4 ;
70666
70667   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70668   arg2 = (Dali::Vector2 *)jarg2;
70669   if (!arg2) {
70670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70671     return ;
70672   }
70673   arg3 = (float)jarg3;
70674   argp4 = (Dali::AlphaFunction *)jarg4;
70675   if (!argp4) {
70676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70677     return ;
70678   }
70679   arg4 = *argp4;
70680   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70681   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
70682   {
70683     try {
70684       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
70685     } catch (std::out_of_range& e) {
70686       {
70687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70688       };
70689     } catch (std::exception& e) {
70690       {
70691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70692       };
70693     } catch (...) {
70694       {
70695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70696       };
70697     }
70698   }
70699 }
70700
70701
70702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
70703   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70704   unsigned int arg2 ;
70705
70706   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70707   arg2 = (unsigned int)jarg2;
70708   {
70709     try {
70710       (arg1)->ScrollTo(arg2);
70711     } catch (std::out_of_range& e) {
70712       {
70713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70714       };
70715     } catch (std::exception& e) {
70716       {
70717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70718       };
70719     } catch (...) {
70720       {
70721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70722       };
70723     }
70724   }
70725 }
70726
70727
70728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
70729   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70730   unsigned int arg2 ;
70731   float arg3 ;
70732
70733   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70734   arg2 = (unsigned int)jarg2;
70735   arg3 = (float)jarg3;
70736   {
70737     try {
70738       (arg1)->ScrollTo(arg2,arg3);
70739     } catch (std::out_of_range& e) {
70740       {
70741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70742       };
70743     } catch (std::exception& e) {
70744       {
70745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70746       };
70747     } catch (...) {
70748       {
70749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70750       };
70751     }
70752   }
70753 }
70754
70755
70756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
70757   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70758   unsigned int arg2 ;
70759   float arg3 ;
70760   Dali::Toolkit::DirectionBias arg4 ;
70761
70762   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70763   arg2 = (unsigned int)jarg2;
70764   arg3 = (float)jarg3;
70765   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70766   {
70767     try {
70768       (arg1)->ScrollTo(arg2,arg3,arg4);
70769     } catch (std::out_of_range& e) {
70770       {
70771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70772       };
70773     } catch (std::exception& e) {
70774       {
70775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70776       };
70777     } catch (...) {
70778       {
70779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70780       };
70781     }
70782   }
70783 }
70784
70785
70786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
70787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70788   Dali::Actor *arg2 = 0 ;
70789
70790   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70791   arg2 = (Dali::Actor *)jarg2;
70792   if (!arg2) {
70793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70794     return ;
70795   }
70796   {
70797     try {
70798       (arg1)->ScrollTo(*arg2);
70799     } catch (std::out_of_range& e) {
70800       {
70801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70802       };
70803     } catch (std::exception& e) {
70804       {
70805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70806       };
70807     } catch (...) {
70808       {
70809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70810       };
70811     }
70812   }
70813 }
70814
70815
70816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
70817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70818   Dali::Actor *arg2 = 0 ;
70819   float arg3 ;
70820
70821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70822   arg2 = (Dali::Actor *)jarg2;
70823   if (!arg2) {
70824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70825     return ;
70826   }
70827   arg3 = (float)jarg3;
70828   {
70829     try {
70830       (arg1)->ScrollTo(*arg2,arg3);
70831     } catch (std::out_of_range& e) {
70832       {
70833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70834       };
70835     } catch (std::exception& e) {
70836       {
70837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70838       };
70839     } catch (...) {
70840       {
70841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70842       };
70843     }
70844   }
70845 }
70846
70847
70848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
70849   unsigned int jresult ;
70850   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70851   bool result;
70852
70853   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70854   {
70855     try {
70856       result = (bool)(arg1)->ScrollToSnapPoint();
70857     } catch (std::out_of_range& e) {
70858       {
70859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70860       };
70861     } catch (std::exception& e) {
70862       {
70863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70864       };
70865     } catch (...) {
70866       {
70867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70868       };
70869     }
70870   }
70871   jresult = result;
70872   return jresult;
70873 }
70874
70875
70876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
70877   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70878   Dali::Constraint arg2 ;
70879   Dali::Constraint *argp2 ;
70880
70881   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70882   argp2 = (Dali::Constraint *)jarg2;
70883   if (!argp2) {
70884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
70885     return ;
70886   }
70887   arg2 = *argp2;
70888   {
70889     try {
70890       (arg1)->ApplyConstraintToChildren(arg2);
70891     } catch (std::out_of_range& e) {
70892       {
70893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70894       };
70895     } catch (std::exception& e) {
70896       {
70897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70898       };
70899     } catch (...) {
70900       {
70901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70902       };
70903     }
70904   }
70905 }
70906
70907
70908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
70909   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70910
70911   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70912   {
70913     try {
70914       (arg1)->RemoveConstraintsFromChildren();
70915     } catch (std::out_of_range& e) {
70916       {
70917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70918       };
70919     } catch (std::exception& e) {
70920       {
70921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70922       };
70923     } catch (...) {
70924       {
70925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70926       };
70927     }
70928   }
70929 }
70930
70931
70932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
70933   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70934   Dali::Toolkit::ScrollViewEffect arg2 ;
70935   Dali::Toolkit::ScrollViewEffect *argp2 ;
70936
70937   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70938   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70939   if (!argp2) {
70940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70941     return ;
70942   }
70943   arg2 = *argp2;
70944   {
70945     try {
70946       (arg1)->ApplyEffect(arg2);
70947     } catch (std::out_of_range& e) {
70948       {
70949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70950       };
70951     } catch (std::exception& e) {
70952       {
70953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70954       };
70955     } catch (...) {
70956       {
70957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70958       };
70959     }
70960   }
70961 }
70962
70963
70964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
70965   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70966   Dali::Toolkit::ScrollViewEffect arg2 ;
70967   Dali::Toolkit::ScrollViewEffect *argp2 ;
70968
70969   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70970   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70971   if (!argp2) {
70972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70973     return ;
70974   }
70975   arg2 = *argp2;
70976   {
70977     try {
70978       (arg1)->RemoveEffect(arg2);
70979     } catch (std::out_of_range& e) {
70980       {
70981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70982       };
70983     } catch (std::exception& e) {
70984       {
70985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70986       };
70987     } catch (...) {
70988       {
70989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70990       };
70991     }
70992   }
70993 }
70994
70995
70996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
70997   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70998
70999   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71000   {
71001     try {
71002       (arg1)->RemoveAllEffects();
71003     } catch (std::out_of_range& e) {
71004       {
71005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71006       };
71007     } catch (std::exception& e) {
71008       {
71009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71010       };
71011     } catch (...) {
71012       {
71013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71014       };
71015     }
71016   }
71017 }
71018
71019
71020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
71021   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71022   Dali::Actor arg2 ;
71023   Dali::Actor *argp2 ;
71024
71025   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71026   argp2 = (Dali::Actor *)jarg2;
71027   if (!argp2) {
71028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71029     return ;
71030   }
71031   arg2 = *argp2;
71032   {
71033     try {
71034       (arg1)->BindActor(arg2);
71035     } catch (std::out_of_range& e) {
71036       {
71037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71038       };
71039     } catch (std::exception& e) {
71040       {
71041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71042       };
71043     } catch (...) {
71044       {
71045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71046       };
71047     }
71048   }
71049 }
71050
71051
71052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
71053   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71054   Dali::Actor arg2 ;
71055   Dali::Actor *argp2 ;
71056
71057   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71058   argp2 = (Dali::Actor *)jarg2;
71059   if (!argp2) {
71060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71061     return ;
71062   }
71063   arg2 = *argp2;
71064   {
71065     try {
71066       (arg1)->UnbindActor(arg2);
71067     } catch (std::out_of_range& e) {
71068       {
71069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71070       };
71071     } catch (std::exception& e) {
71072       {
71073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71074       };
71075     } catch (...) {
71076       {
71077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71078       };
71079     }
71080   }
71081 }
71082
71083
71084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
71085   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71086   Dali::Radian arg2 ;
71087   Dali::Radian arg3 ;
71088   Dali::Radian *argp2 ;
71089   Dali::Radian *argp3 ;
71090
71091   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71092   argp2 = (Dali::Radian *)jarg2;
71093   if (!argp2) {
71094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
71095     return ;
71096   }
71097   arg2 = *argp2;
71098   argp3 = (Dali::Radian *)jarg3;
71099   if (!argp3) {
71100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
71101     return ;
71102   }
71103   arg3 = *argp3;
71104   {
71105     try {
71106       (arg1)->SetScrollingDirection(arg2,arg3);
71107     } catch (std::out_of_range& e) {
71108       {
71109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71110       };
71111     } catch (std::exception& e) {
71112       {
71113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71114       };
71115     } catch (...) {
71116       {
71117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71118       };
71119     }
71120   }
71121 }
71122
71123
71124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
71125   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71126   Dali::Radian arg2 ;
71127   Dali::Radian *argp2 ;
71128
71129   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71130   argp2 = (Dali::Radian *)jarg2;
71131   if (!argp2) {
71132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
71133     return ;
71134   }
71135   arg2 = *argp2;
71136   {
71137     try {
71138       (arg1)->SetScrollingDirection(arg2);
71139     } catch (std::out_of_range& e) {
71140       {
71141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71142       };
71143     } catch (std::exception& e) {
71144       {
71145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71146       };
71147     } catch (...) {
71148       {
71149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71150       };
71151     }
71152   }
71153 }
71154
71155
71156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
71157   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71158   Dali::Radian arg2 ;
71159   Dali::Radian *argp2 ;
71160
71161   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71162   argp2 = (Dali::Radian *)jarg2;
71163   if (!argp2) {
71164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
71165     return ;
71166   }
71167   arg2 = *argp2;
71168   {
71169     try {
71170       (arg1)->RemoveScrollingDirection(arg2);
71171     } catch (std::out_of_range& e) {
71172       {
71173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71174       };
71175     } catch (std::exception& e) {
71176       {
71177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71178       };
71179     } catch (...) {
71180       {
71181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71182       };
71183     }
71184   }
71185 }
71186
71187
71188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
71189   void * jresult ;
71190   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71191   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
71192
71193   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71194   {
71195     try {
71196       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
71197     } catch (std::out_of_range& e) {
71198       {
71199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71200       };
71201     } catch (std::exception& e) {
71202       {
71203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71204       };
71205     } catch (...) {
71206       {
71207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71208       };
71209     }
71210   }
71211   jresult = (void *)result;
71212   return jresult;
71213 }
71214
71215
71216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
71217   int jresult ;
71218   int result;
71219
71220   result = (int)Dali::Toolkit::TableView::Property::ROWS;
71221   jresult = (int)result;
71222   return jresult;
71223 }
71224
71225
71226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
71227   int jresult ;
71228   int result;
71229
71230   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
71231   jresult = (int)result;
71232   return jresult;
71233 }
71234
71235
71236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
71237   int jresult ;
71238   int result;
71239
71240   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
71241   jresult = (int)result;
71242   return jresult;
71243 }
71244
71245
71246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
71247   int jresult ;
71248   int result;
71249
71250   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
71251   jresult = (int)result;
71252   return jresult;
71253 }
71254
71255
71256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
71257   int jresult ;
71258   int result;
71259
71260   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
71261   jresult = (int)result;
71262   return jresult;
71263 }
71264
71265
71266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
71267   void * jresult ;
71268   Dali::Toolkit::TableView::Property *result = 0 ;
71269
71270   {
71271     try {
71272       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
71273     } catch (std::out_of_range& e) {
71274       {
71275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71276       };
71277     } catch (std::exception& e) {
71278       {
71279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71280       };
71281     } catch (...) {
71282       {
71283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71284       };
71285     }
71286   }
71287   jresult = (void *)result;
71288   return jresult;
71289 }
71290
71291
71292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
71293   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
71294
71295   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
71296   {
71297     try {
71298       delete arg1;
71299     } catch (std::out_of_range& e) {
71300       {
71301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71302       };
71303     } catch (std::exception& e) {
71304       {
71305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71306       };
71307     } catch (...) {
71308       {
71309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71310       };
71311     }
71312   }
71313 }
71314
71315
71316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
71317   int jresult ;
71318   int result;
71319
71320   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
71321   jresult = (int)result;
71322   return jresult;
71323 }
71324
71325
71326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
71327   int jresult ;
71328   int result;
71329
71330   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
71331   jresult = (int)result;
71332   return jresult;
71333 }
71334
71335
71336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
71337   int jresult ;
71338   int result;
71339
71340   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
71341   jresult = (int)result;
71342   return jresult;
71343 }
71344
71345
71346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
71347   int jresult ;
71348   int result;
71349
71350   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
71351   jresult = (int)result;
71352   return jresult;
71353 }
71354
71355
71356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
71357   int jresult ;
71358   int result;
71359
71360   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
71361   jresult = (int)result;
71362   return jresult;
71363 }
71364
71365
71366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
71367   void * jresult ;
71368   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
71369
71370   {
71371     try {
71372       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
71373     } catch (std::out_of_range& e) {
71374       {
71375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71376       };
71377     } catch (std::exception& e) {
71378       {
71379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71380       };
71381     } catch (...) {
71382       {
71383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71384       };
71385     }
71386   }
71387   jresult = (void *)result;
71388   return jresult;
71389 }
71390
71391
71392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
71393   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
71394
71395   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
71396   {
71397     try {
71398       delete arg1;
71399     } catch (std::out_of_range& e) {
71400       {
71401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71402       };
71403     } catch (std::exception& e) {
71404       {
71405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71406       };
71407     } catch (...) {
71408       {
71409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71410       };
71411     }
71412   }
71413 }
71414
71415
71416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
71417   void * jresult ;
71418   unsigned int arg1 ;
71419   unsigned int arg2 ;
71420   unsigned int arg3 ;
71421   unsigned int arg4 ;
71422   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71423
71424   arg1 = (unsigned int)jarg1;
71425   arg2 = (unsigned int)jarg2;
71426   arg3 = (unsigned int)jarg3;
71427   arg4 = (unsigned int)jarg4;
71428   {
71429     try {
71430       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
71431     } catch (std::out_of_range& e) {
71432       {
71433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71434       };
71435     } catch (std::exception& e) {
71436       {
71437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71438       };
71439     } catch (...) {
71440       {
71441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71442       };
71443     }
71444   }
71445   jresult = (void *)result;
71446   return jresult;
71447 }
71448
71449
71450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
71451   void * jresult ;
71452   unsigned int arg1 ;
71453   unsigned int arg2 ;
71454   unsigned int arg3 ;
71455   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71456
71457   arg1 = (unsigned int)jarg1;
71458   arg2 = (unsigned int)jarg2;
71459   arg3 = (unsigned int)jarg3;
71460   {
71461     try {
71462       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
71463     } catch (std::out_of_range& e) {
71464       {
71465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71466       };
71467     } catch (std::exception& e) {
71468       {
71469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71470       };
71471     } catch (...) {
71472       {
71473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71474       };
71475     }
71476   }
71477   jresult = (void *)result;
71478   return jresult;
71479 }
71480
71481
71482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
71483   void * jresult ;
71484   unsigned int arg1 ;
71485   unsigned int arg2 ;
71486   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71487
71488   arg1 = (unsigned int)jarg1;
71489   arg2 = (unsigned int)jarg2;
71490   {
71491     try {
71492       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
71493     } catch (std::out_of_range& e) {
71494       {
71495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71496       };
71497     } catch (std::exception& e) {
71498       {
71499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71500       };
71501     } catch (...) {
71502       {
71503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71504       };
71505     }
71506   }
71507   jresult = (void *)result;
71508   return jresult;
71509 }
71510
71511
71512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
71513   void * jresult ;
71514   unsigned int arg1 ;
71515   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71516
71517   arg1 = (unsigned int)jarg1;
71518   {
71519     try {
71520       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
71521     } catch (std::out_of_range& e) {
71522       {
71523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71524       };
71525     } catch (std::exception& e) {
71526       {
71527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71528       };
71529     } catch (...) {
71530       {
71531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71532       };
71533     }
71534   }
71535   jresult = (void *)result;
71536   return jresult;
71537 }
71538
71539
71540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
71541   void * jresult ;
71542   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71543
71544   {
71545     try {
71546       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
71547     } catch (std::out_of_range& e) {
71548       {
71549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71550       };
71551     } catch (std::exception& e) {
71552       {
71553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71554       };
71555     } catch (...) {
71556       {
71557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71558       };
71559     }
71560   }
71561   jresult = (void *)result;
71562   return jresult;
71563 }
71564
71565
71566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
71567   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71568   unsigned int arg2 ;
71569
71570   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71571   arg2 = (unsigned int)jarg2;
71572   if (arg1) (arg1)->rowIndex = arg2;
71573 }
71574
71575
71576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
71577   unsigned int jresult ;
71578   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71579   unsigned int result;
71580
71581   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71582   result = (unsigned int) ((arg1)->rowIndex);
71583   jresult = result;
71584   return jresult;
71585 }
71586
71587
71588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
71589   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71590   unsigned int arg2 ;
71591
71592   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71593   arg2 = (unsigned int)jarg2;
71594   if (arg1) (arg1)->columnIndex = arg2;
71595 }
71596
71597
71598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
71599   unsigned int jresult ;
71600   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71601   unsigned int result;
71602
71603   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71604   result = (unsigned int) ((arg1)->columnIndex);
71605   jresult = result;
71606   return jresult;
71607 }
71608
71609
71610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
71611   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71612   unsigned int arg2 ;
71613
71614   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71615   arg2 = (unsigned int)jarg2;
71616   if (arg1) (arg1)->rowSpan = arg2;
71617 }
71618
71619
71620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
71621   unsigned int jresult ;
71622   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71623   unsigned int result;
71624
71625   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71626   result = (unsigned int) ((arg1)->rowSpan);
71627   jresult = result;
71628   return jresult;
71629 }
71630
71631
71632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
71633   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71634   unsigned int arg2 ;
71635
71636   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71637   arg2 = (unsigned int)jarg2;
71638   if (arg1) (arg1)->columnSpan = arg2;
71639 }
71640
71641
71642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
71643   unsigned int jresult ;
71644   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71645   unsigned int result;
71646
71647   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71648   result = (unsigned int) ((arg1)->columnSpan);
71649   jresult = result;
71650   return jresult;
71651 }
71652
71653
71654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
71655   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71656
71657   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71658   {
71659     try {
71660       delete arg1;
71661     } catch (std::out_of_range& e) {
71662       {
71663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71664       };
71665     } catch (std::exception& e) {
71666       {
71667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71668       };
71669     } catch (...) {
71670       {
71671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71672       };
71673     }
71674   }
71675 }
71676
71677
71678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
71679   void * jresult ;
71680   Dali::Toolkit::TableView *result = 0 ;
71681
71682   {
71683     try {
71684       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
71685     } catch (std::out_of_range& e) {
71686       {
71687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71688       };
71689     } catch (std::exception& e) {
71690       {
71691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71692       };
71693     } catch (...) {
71694       {
71695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71696       };
71697     }
71698   }
71699   jresult = (void *)result;
71700   return jresult;
71701 }
71702
71703
71704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
71705   void * jresult ;
71706   Dali::Toolkit::TableView *arg1 = 0 ;
71707   Dali::Toolkit::TableView *result = 0 ;
71708
71709   arg1 = (Dali::Toolkit::TableView *)jarg1;
71710   if (!arg1) {
71711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71712     return 0;
71713   }
71714   {
71715     try {
71716       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
71717     } catch (std::out_of_range& e) {
71718       {
71719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71720       };
71721     } catch (std::exception& e) {
71722       {
71723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71724       };
71725     } catch (...) {
71726       {
71727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71728       };
71729     }
71730   }
71731   jresult = (void *)result;
71732   return jresult;
71733 }
71734
71735
71736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
71737   void * jresult ;
71738   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71739   Dali::Toolkit::TableView *arg2 = 0 ;
71740   Dali::Toolkit::TableView *result = 0 ;
71741
71742   arg1 = (Dali::Toolkit::TableView *)jarg1;
71743   arg2 = (Dali::Toolkit::TableView *)jarg2;
71744   if (!arg2) {
71745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71746     return 0;
71747   }
71748   {
71749     try {
71750       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
71751     } catch (std::out_of_range& e) {
71752       {
71753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71754       };
71755     } catch (std::exception& e) {
71756       {
71757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71758       };
71759     } catch (...) {
71760       {
71761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71762       };
71763     }
71764   }
71765   jresult = (void *)result;
71766   return jresult;
71767 }
71768
71769
71770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
71771   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71772
71773   arg1 = (Dali::Toolkit::TableView *)jarg1;
71774   {
71775     try {
71776       delete arg1;
71777     } catch (std::out_of_range& e) {
71778       {
71779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71780       };
71781     } catch (std::exception& e) {
71782       {
71783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71784       };
71785     } catch (...) {
71786       {
71787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71788       };
71789     }
71790   }
71791 }
71792
71793
71794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
71795   void * jresult ;
71796   unsigned int arg1 ;
71797   unsigned int arg2 ;
71798   Dali::Toolkit::TableView result;
71799
71800   arg1 = (unsigned int)jarg1;
71801   arg2 = (unsigned int)jarg2;
71802   {
71803     try {
71804       result = Dali::Toolkit::TableView::New(arg1,arg2);
71805     } catch (std::out_of_range& e) {
71806       {
71807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71808       };
71809     } catch (std::exception& e) {
71810       {
71811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71812       };
71813     } catch (...) {
71814       {
71815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71816       };
71817     }
71818   }
71819   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71820   return jresult;
71821 }
71822
71823
71824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
71825   void * jresult ;
71826   Dali::BaseHandle arg1 ;
71827   Dali::BaseHandle *argp1 ;
71828   Dali::Toolkit::TableView result;
71829
71830   argp1 = (Dali::BaseHandle *)jarg1;
71831   if (!argp1) {
71832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71833     return 0;
71834   }
71835   arg1 = *argp1;
71836   {
71837     try {
71838       result = Dali::Toolkit::TableView::DownCast(arg1);
71839     } catch (std::out_of_range& e) {
71840       {
71841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71842       };
71843     } catch (std::exception& e) {
71844       {
71845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71846       };
71847     } catch (...) {
71848       {
71849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71850       };
71851     }
71852   }
71853   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71854   return jresult;
71855 }
71856
71857
71858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
71859   unsigned int jresult ;
71860   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71861   Dali::Actor arg2 ;
71862   Dali::Toolkit::TableView::CellPosition arg3 ;
71863   Dali::Actor *argp2 ;
71864   Dali::Toolkit::TableView::CellPosition *argp3 ;
71865   bool result;
71866
71867   arg1 = (Dali::Toolkit::TableView *)jarg1;
71868   argp2 = (Dali::Actor *)jarg2;
71869   if (!argp2) {
71870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71871     return 0;
71872   }
71873   arg2 = *argp2;
71874   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71875   if (!argp3) {
71876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71877     return 0;
71878   }
71879   arg3 = *argp3;
71880   {
71881     try {
71882       result = (bool)(arg1)->AddChild(arg2,arg3);
71883     } catch (std::out_of_range& e) {
71884       {
71885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71886       };
71887     } catch (std::exception& e) {
71888       {
71889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71890       };
71891     } catch (...) {
71892       {
71893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71894       };
71895     }
71896   }
71897   jresult = result;
71898   return jresult;
71899 }
71900
71901
71902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
71903   void * jresult ;
71904   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71905   Dali::Toolkit::TableView::CellPosition arg2 ;
71906   Dali::Toolkit::TableView::CellPosition *argp2 ;
71907   Dali::Actor result;
71908
71909   arg1 = (Dali::Toolkit::TableView *)jarg1;
71910   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71911   if (!argp2) {
71912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71913     return 0;
71914   }
71915   arg2 = *argp2;
71916   {
71917     try {
71918       result = (arg1)->GetChildAt(arg2);
71919     } catch (std::out_of_range& e) {
71920       {
71921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71922       };
71923     } catch (std::exception& e) {
71924       {
71925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71926       };
71927     } catch (...) {
71928       {
71929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71930       };
71931     }
71932   }
71933   jresult = new Dali::Actor((const Dali::Actor &)result);
71934   return jresult;
71935 }
71936
71937
71938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
71939   void * jresult ;
71940   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71941   Dali::Toolkit::TableView::CellPosition arg2 ;
71942   Dali::Toolkit::TableView::CellPosition *argp2 ;
71943   Dali::Actor result;
71944
71945   arg1 = (Dali::Toolkit::TableView *)jarg1;
71946   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71947   if (!argp2) {
71948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71949     return 0;
71950   }
71951   arg2 = *argp2;
71952   {
71953     try {
71954       result = (arg1)->RemoveChildAt(arg2);
71955     } catch (std::out_of_range& e) {
71956       {
71957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71958       };
71959     } catch (std::exception& e) {
71960       {
71961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71962       };
71963     } catch (...) {
71964       {
71965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71966       };
71967     }
71968   }
71969   jresult = new Dali::Actor((const Dali::Actor &)result);
71970   return jresult;
71971 }
71972
71973
71974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
71975   unsigned int jresult ;
71976   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71977   Dali::Actor arg2 ;
71978   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
71979   Dali::Actor *argp2 ;
71980   bool result;
71981
71982   arg1 = (Dali::Toolkit::TableView *)jarg1;
71983   argp2 = (Dali::Actor *)jarg2;
71984   if (!argp2) {
71985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71986     return 0;
71987   }
71988   arg2 = *argp2;
71989   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71990   if (!arg3) {
71991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
71992     return 0;
71993   }
71994   {
71995     try {
71996       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
71997     } catch (std::out_of_range& e) {
71998       {
71999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72000       };
72001     } catch (std::exception& e) {
72002       {
72003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72004       };
72005     } catch (...) {
72006       {
72007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72008       };
72009     }
72010   }
72011   jresult = result;
72012   return jresult;
72013 }
72014
72015
72016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
72017   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72018   unsigned int arg2 ;
72019
72020   arg1 = (Dali::Toolkit::TableView *)jarg1;
72021   arg2 = (unsigned int)jarg2;
72022   {
72023     try {
72024       (arg1)->InsertRow(arg2);
72025     } catch (std::out_of_range& e) {
72026       {
72027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72028       };
72029     } catch (std::exception& e) {
72030       {
72031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72032       };
72033     } catch (...) {
72034       {
72035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72036       };
72037     }
72038   }
72039 }
72040
72041
72042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
72043   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72044   unsigned int arg2 ;
72045
72046   arg1 = (Dali::Toolkit::TableView *)jarg1;
72047   arg2 = (unsigned int)jarg2;
72048   {
72049     try {
72050       (arg1)->DeleteRow(arg2);
72051     } catch (std::out_of_range& e) {
72052       {
72053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72054       };
72055     } catch (std::exception& e) {
72056       {
72057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72058       };
72059     } catch (...) {
72060       {
72061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72062       };
72063     }
72064   }
72065 }
72066
72067
72068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
72069   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72070   unsigned int arg2 ;
72071   std::vector< Dali::Actor > *arg3 = 0 ;
72072
72073   arg1 = (Dali::Toolkit::TableView *)jarg1;
72074   arg2 = (unsigned int)jarg2;
72075   arg3 = (std::vector< Dali::Actor > *)jarg3;
72076   if (!arg3) {
72077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72078     return ;
72079   }
72080   {
72081     try {
72082       (arg1)->DeleteRow(arg2,*arg3);
72083     } catch (std::out_of_range& e) {
72084       {
72085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72086       };
72087     } catch (std::exception& e) {
72088       {
72089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72090       };
72091     } catch (...) {
72092       {
72093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72094       };
72095     }
72096   }
72097 }
72098
72099
72100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
72101   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72102   unsigned int arg2 ;
72103
72104   arg1 = (Dali::Toolkit::TableView *)jarg1;
72105   arg2 = (unsigned int)jarg2;
72106   {
72107     try {
72108       (arg1)->InsertColumn(arg2);
72109     } catch (std::out_of_range& e) {
72110       {
72111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72112       };
72113     } catch (std::exception& e) {
72114       {
72115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72116       };
72117     } catch (...) {
72118       {
72119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72120       };
72121     }
72122   }
72123 }
72124
72125
72126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
72127   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72128   unsigned int arg2 ;
72129
72130   arg1 = (Dali::Toolkit::TableView *)jarg1;
72131   arg2 = (unsigned int)jarg2;
72132   {
72133     try {
72134       (arg1)->DeleteColumn(arg2);
72135     } catch (std::out_of_range& e) {
72136       {
72137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72138       };
72139     } catch (std::exception& e) {
72140       {
72141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72142       };
72143     } catch (...) {
72144       {
72145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72146       };
72147     }
72148   }
72149 }
72150
72151
72152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
72153   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72154   unsigned int arg2 ;
72155   std::vector< Dali::Actor > *arg3 = 0 ;
72156
72157   arg1 = (Dali::Toolkit::TableView *)jarg1;
72158   arg2 = (unsigned int)jarg2;
72159   arg3 = (std::vector< Dali::Actor > *)jarg3;
72160   if (!arg3) {
72161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72162     return ;
72163   }
72164   {
72165     try {
72166       (arg1)->DeleteColumn(arg2,*arg3);
72167     } catch (std::out_of_range& e) {
72168       {
72169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72170       };
72171     } catch (std::exception& e) {
72172       {
72173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72174       };
72175     } catch (...) {
72176       {
72177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72178       };
72179     }
72180   }
72181 }
72182
72183
72184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
72185   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72186   unsigned int arg2 ;
72187   unsigned int arg3 ;
72188
72189   arg1 = (Dali::Toolkit::TableView *)jarg1;
72190   arg2 = (unsigned int)jarg2;
72191   arg3 = (unsigned int)jarg3;
72192   {
72193     try {
72194       (arg1)->Resize(arg2,arg3);
72195     } catch (std::out_of_range& e) {
72196       {
72197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72198       };
72199     } catch (std::exception& e) {
72200       {
72201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72202       };
72203     } catch (...) {
72204       {
72205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72206       };
72207     }
72208   }
72209 }
72210
72211
72212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
72213   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72214   unsigned int arg2 ;
72215   unsigned int arg3 ;
72216   std::vector< Dali::Actor > *arg4 = 0 ;
72217
72218   arg1 = (Dali::Toolkit::TableView *)jarg1;
72219   arg2 = (unsigned int)jarg2;
72220   arg3 = (unsigned int)jarg3;
72221   arg4 = (std::vector< Dali::Actor > *)jarg4;
72222   if (!arg4) {
72223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72224     return ;
72225   }
72226   {
72227     try {
72228       (arg1)->Resize(arg2,arg3,*arg4);
72229     } catch (std::out_of_range& e) {
72230       {
72231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72232       };
72233     } catch (std::exception& e) {
72234       {
72235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72236       };
72237     } catch (...) {
72238       {
72239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72240       };
72241     }
72242   }
72243 }
72244
72245
72246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
72247   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72248   Dali::Size arg2 ;
72249   Dali::Size *argp2 ;
72250
72251   arg1 = (Dali::Toolkit::TableView *)jarg1;
72252   argp2 = (Dali::Size *)jarg2;
72253   if (!argp2) {
72254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
72255     return ;
72256   }
72257   arg2 = *argp2;
72258   {
72259     try {
72260       (arg1)->SetCellPadding(arg2);
72261     } catch (std::out_of_range& e) {
72262       {
72263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72264       };
72265     } catch (std::exception& e) {
72266       {
72267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72268       };
72269     } catch (...) {
72270       {
72271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72272       };
72273     }
72274   }
72275 }
72276
72277
72278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
72279   void * jresult ;
72280   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72281   Dali::Size result;
72282
72283   arg1 = (Dali::Toolkit::TableView *)jarg1;
72284   {
72285     try {
72286       result = (arg1)->GetCellPadding();
72287     } catch (std::out_of_range& e) {
72288       {
72289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72290       };
72291     } catch (std::exception& e) {
72292       {
72293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72294       };
72295     } catch (...) {
72296       {
72297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72298       };
72299     }
72300   }
72301   jresult = new Dali::Size((const Dali::Size &)result);
72302   return jresult;
72303 }
72304
72305
72306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
72307   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72308   unsigned int arg2 ;
72309
72310   arg1 = (Dali::Toolkit::TableView *)jarg1;
72311   arg2 = (unsigned int)jarg2;
72312   {
72313     try {
72314       (arg1)->SetFitHeight(arg2);
72315     } catch (std::out_of_range& e) {
72316       {
72317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72318       };
72319     } catch (std::exception& e) {
72320       {
72321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72322       };
72323     } catch (...) {
72324       {
72325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72326       };
72327     }
72328   }
72329 }
72330
72331
72332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
72333   unsigned int jresult ;
72334   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72335   unsigned int arg2 ;
72336   bool result;
72337
72338   arg1 = (Dali::Toolkit::TableView *)jarg1;
72339   arg2 = (unsigned int)jarg2;
72340   {
72341     try {
72342       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
72343     } catch (std::out_of_range& e) {
72344       {
72345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72346       };
72347     } catch (std::exception& e) {
72348       {
72349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72350       };
72351     } catch (...) {
72352       {
72353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72354       };
72355     }
72356   }
72357   jresult = result;
72358   return jresult;
72359 }
72360
72361
72362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
72363   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72364   unsigned int arg2 ;
72365
72366   arg1 = (Dali::Toolkit::TableView *)jarg1;
72367   arg2 = (unsigned int)jarg2;
72368   {
72369     try {
72370       (arg1)->SetFitWidth(arg2);
72371     } catch (std::out_of_range& e) {
72372       {
72373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72374       };
72375     } catch (std::exception& e) {
72376       {
72377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72378       };
72379     } catch (...) {
72380       {
72381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72382       };
72383     }
72384   }
72385 }
72386
72387
72388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
72389   unsigned int jresult ;
72390   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72391   unsigned int arg2 ;
72392   bool result;
72393
72394   arg1 = (Dali::Toolkit::TableView *)jarg1;
72395   arg2 = (unsigned int)jarg2;
72396   {
72397     try {
72398       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
72399     } catch (std::out_of_range& e) {
72400       {
72401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72402       };
72403     } catch (std::exception& e) {
72404       {
72405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72406       };
72407     } catch (...) {
72408       {
72409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72410       };
72411     }
72412   }
72413   jresult = result;
72414   return jresult;
72415 }
72416
72417
72418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72419   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72420   unsigned int arg2 ;
72421   float arg3 ;
72422
72423   arg1 = (Dali::Toolkit::TableView *)jarg1;
72424   arg2 = (unsigned int)jarg2;
72425   arg3 = (float)jarg3;
72426   {
72427     try {
72428       (arg1)->SetFixedHeight(arg2,arg3);
72429     } catch (std::out_of_range& e) {
72430       {
72431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72432       };
72433     } catch (std::exception& e) {
72434       {
72435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72436       };
72437     } catch (...) {
72438       {
72439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72440       };
72441     }
72442   }
72443 }
72444
72445
72446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
72447   float jresult ;
72448   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72449   unsigned int arg2 ;
72450   float result;
72451
72452   arg1 = (Dali::Toolkit::TableView *)jarg1;
72453   arg2 = (unsigned int)jarg2;
72454   {
72455     try {
72456       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
72457     } catch (std::out_of_range& e) {
72458       {
72459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72460       };
72461     } catch (std::exception& e) {
72462       {
72463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72464       };
72465     } catch (...) {
72466       {
72467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72468       };
72469     }
72470   }
72471   jresult = result;
72472   return jresult;
72473 }
72474
72475
72476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72477   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72478   unsigned int arg2 ;
72479   float arg3 ;
72480
72481   arg1 = (Dali::Toolkit::TableView *)jarg1;
72482   arg2 = (unsigned int)jarg2;
72483   arg3 = (float)jarg3;
72484   {
72485     try {
72486       (arg1)->SetRelativeHeight(arg2,arg3);
72487     } catch (std::out_of_range& e) {
72488       {
72489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72490       };
72491     } catch (std::exception& e) {
72492       {
72493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72494       };
72495     } catch (...) {
72496       {
72497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72498       };
72499     }
72500   }
72501 }
72502
72503
72504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
72505   float jresult ;
72506   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72507   unsigned int arg2 ;
72508   float result;
72509
72510   arg1 = (Dali::Toolkit::TableView *)jarg1;
72511   arg2 = (unsigned int)jarg2;
72512   {
72513     try {
72514       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
72515     } catch (std::out_of_range& e) {
72516       {
72517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72518       };
72519     } catch (std::exception& e) {
72520       {
72521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72522       };
72523     } catch (...) {
72524       {
72525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72526       };
72527     }
72528   }
72529   jresult = result;
72530   return jresult;
72531 }
72532
72533
72534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72535   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72536   unsigned int arg2 ;
72537   float arg3 ;
72538
72539   arg1 = (Dali::Toolkit::TableView *)jarg1;
72540   arg2 = (unsigned int)jarg2;
72541   arg3 = (float)jarg3;
72542   {
72543     try {
72544       (arg1)->SetFixedWidth(arg2,arg3);
72545     } catch (std::out_of_range& e) {
72546       {
72547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72548       };
72549     } catch (std::exception& e) {
72550       {
72551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72552       };
72553     } catch (...) {
72554       {
72555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72556       };
72557     }
72558   }
72559 }
72560
72561
72562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
72563   float jresult ;
72564   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72565   unsigned int arg2 ;
72566   float result;
72567
72568   arg1 = (Dali::Toolkit::TableView *)jarg1;
72569   arg2 = (unsigned int)jarg2;
72570   {
72571     try {
72572       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
72573     } catch (std::out_of_range& e) {
72574       {
72575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72576       };
72577     } catch (std::exception& e) {
72578       {
72579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72580       };
72581     } catch (...) {
72582       {
72583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72584       };
72585     }
72586   }
72587   jresult = result;
72588   return jresult;
72589 }
72590
72591
72592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72593   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72594   unsigned int arg2 ;
72595   float arg3 ;
72596
72597   arg1 = (Dali::Toolkit::TableView *)jarg1;
72598   arg2 = (unsigned int)jarg2;
72599   arg3 = (float)jarg3;
72600   {
72601     try {
72602       (arg1)->SetRelativeWidth(arg2,arg3);
72603     } catch (std::out_of_range& e) {
72604       {
72605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72606       };
72607     } catch (std::exception& e) {
72608       {
72609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72610       };
72611     } catch (...) {
72612       {
72613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72614       };
72615     }
72616   }
72617 }
72618
72619
72620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
72621   float jresult ;
72622   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72623   unsigned int arg2 ;
72624   float result;
72625
72626   arg1 = (Dali::Toolkit::TableView *)jarg1;
72627   arg2 = (unsigned int)jarg2;
72628   {
72629     try {
72630       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
72631     } catch (std::out_of_range& e) {
72632       {
72633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72634       };
72635     } catch (std::exception& e) {
72636       {
72637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72638       };
72639     } catch (...) {
72640       {
72641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72642       };
72643     }
72644   }
72645   jresult = result;
72646   return jresult;
72647 }
72648
72649
72650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
72651   unsigned int jresult ;
72652   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72653   unsigned int result;
72654
72655   arg1 = (Dali::Toolkit::TableView *)jarg1;
72656   {
72657     try {
72658       result = (unsigned int)(arg1)->GetRows();
72659     } catch (std::out_of_range& e) {
72660       {
72661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72662       };
72663     } catch (std::exception& e) {
72664       {
72665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72666       };
72667     } catch (...) {
72668       {
72669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72670       };
72671     }
72672   }
72673   jresult = result;
72674   return jresult;
72675 }
72676
72677
72678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
72679   unsigned int jresult ;
72680   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72681   unsigned int result;
72682
72683   arg1 = (Dali::Toolkit::TableView *)jarg1;
72684   {
72685     try {
72686       result = (unsigned int)(arg1)->GetColumns();
72687     } catch (std::out_of_range& e) {
72688       {
72689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72690       };
72691     } catch (std::exception& e) {
72692       {
72693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72694       };
72695     } catch (...) {
72696       {
72697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72698       };
72699     }
72700   }
72701   jresult = result;
72702   return jresult;
72703 }
72704
72705
72706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
72707   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72708   Dali::Toolkit::TableView::CellPosition arg2 ;
72709   Dali::HorizontalAlignment::Type arg3 ;
72710   Dali::VerticalAlignment::Type arg4 ;
72711   Dali::Toolkit::TableView::CellPosition *argp2 ;
72712
72713   arg1 = (Dali::Toolkit::TableView *)jarg1;
72714   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
72715   if (!argp2) {
72716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
72717     return ;
72718   }
72719   arg2 = *argp2;
72720   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
72721   arg4 = (Dali::VerticalAlignment::Type)jarg4;
72722   {
72723     try {
72724       (arg1)->SetCellAlignment(arg2,arg3,arg4);
72725     } catch (std::out_of_range& e) {
72726       {
72727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72728       };
72729     } catch (std::exception& e) {
72730       {
72731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72732       };
72733     } catch (...) {
72734       {
72735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72736       };
72737     }
72738   }
72739 }
72740
72741
72742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
72743   unsigned int jresult ;
72744   unsigned int result;
72745
72746   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
72747   jresult = result;
72748   return jresult;
72749 }
72750
72751
72752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
72753   int jresult ;
72754   int result;
72755
72756   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
72757   jresult = (int)result;
72758   return jresult;
72759 }
72760
72761
72762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
72763   int jresult ;
72764   int result;
72765
72766   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
72767   jresult = (int)result;
72768   return jresult;
72769 }
72770
72771
72772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
72773   int jresult ;
72774   int result;
72775
72776   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
72777   jresult = (int)result;
72778   return jresult;
72779 }
72780
72781
72782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
72783   int jresult ;
72784   int result;
72785
72786   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
72787   jresult = (int)result;
72788   return jresult;
72789 }
72790
72791
72792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
72793   int jresult ;
72794   int result;
72795
72796   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
72797   jresult = (int)result;
72798   return jresult;
72799 }
72800
72801
72802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
72803   int jresult ;
72804   int result;
72805
72806   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
72807   jresult = (int)result;
72808   return jresult;
72809 }
72810
72811
72812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
72813   int jresult ;
72814   int result;
72815
72816   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
72817   jresult = (int)result;
72818   return jresult;
72819 }
72820
72821
72822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
72823   int jresult ;
72824   int result;
72825
72826   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
72827   jresult = (int)result;
72828   return jresult;
72829 }
72830
72831
72832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
72833   int jresult ;
72834   int result;
72835
72836   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
72837   jresult = (int)result;
72838   return jresult;
72839 }
72840
72841
72842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
72843   int jresult ;
72844   int result;
72845
72846   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
72847   jresult = (int)result;
72848   return jresult;
72849 }
72850
72851
72852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
72853   int jresult ;
72854   int result;
72855
72856   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
72857   jresult = (int)result;
72858   return jresult;
72859 }
72860
72861
72862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
72863   int jresult ;
72864   int result;
72865
72866   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
72867   jresult = (int)result;
72868   return jresult;
72869 }
72870
72871
72872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
72873   int jresult ;
72874   int result;
72875
72876   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
72877   jresult = (int)result;
72878   return jresult;
72879 }
72880
72881
72882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
72883   int jresult ;
72884   int result;
72885
72886   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
72887   jresult = (int)result;
72888   return jresult;
72889 }
72890
72891
72892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
72893   int jresult ;
72894   int result;
72895
72896   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
72897   jresult = (int)result;
72898   return jresult;
72899 }
72900
72901
72902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
72903   int jresult ;
72904   int result;
72905
72906   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
72907   jresult = (int)result;
72908   return jresult;
72909 }
72910
72911
72912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
72913   int jresult ;
72914   int result;
72915
72916   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
72917   jresult = (int)result;
72918   return jresult;
72919 }
72920
72921
72922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
72923   int jresult ;
72924   int result;
72925
72926   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
72927   jresult = (int)result;
72928   return jresult;
72929 }
72930
72931
72932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
72933   int jresult ;
72934   int result;
72935
72936   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
72937   jresult = (int)result;
72938   return jresult;
72939 }
72940
72941
72942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
72943   int jresult ;
72944   int result;
72945
72946   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
72947   jresult = (int)result;
72948   return jresult;
72949 }
72950
72951
72952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
72953   int jresult ;
72954   int result;
72955
72956   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
72957   jresult = (int)result;
72958   return jresult;
72959 }
72960
72961
72962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
72963   int jresult ;
72964   int result;
72965
72966   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
72967   jresult = (int)result;
72968   return jresult;
72969 }
72970
72971
72972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
72973   int jresult ;
72974   int result;
72975
72976   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
72977   jresult = (int)result;
72978   return jresult;
72979 }
72980
72981
72982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
72983   int jresult ;
72984   int result;
72985
72986   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
72987   jresult = (int)result;
72988   return jresult;
72989 }
72990
72991
72992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
72993   int jresult ;
72994   int result;
72995
72996   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
72997   jresult = (int)result;
72998   return jresult;
72999 }
73000
73001
73002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
73003   int jresult ;
73004   int result;
73005
73006   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
73007   jresult = (int)result;
73008   return jresult;
73009 }
73010
73011
73012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
73013   int jresult ;
73014   int result;
73015
73016   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
73017   jresult = (int)result;
73018   return jresult;
73019 }
73020
73021
73022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
73023   int jresult ;
73024   int result;
73025
73026   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
73027   jresult = (int)result;
73028   return jresult;
73029 }
73030
73031
73032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
73033   int jresult ;
73034   int result;
73035
73036   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
73037   jresult = (int)result;
73038   return jresult;
73039 }
73040
73041
73042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
73043   int jresult ;
73044   int result;
73045
73046   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
73047   jresult = (int)result;
73048   return jresult;
73049 }
73050
73051
73052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
73053   int jresult ;
73054   int result;
73055
73056   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
73057   jresult = (int)result;
73058   return jresult;
73059 }
73060
73061
73062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
73063   int jresult ;
73064   int result;
73065
73066   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
73067   jresult = (int)result;
73068   return jresult;
73069 }
73070
73071
73072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
73073   int jresult ;
73074   int result;
73075
73076   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
73077   jresult = (int)result;
73078   return jresult;
73079 }
73080
73081
73082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
73083   int jresult ;
73084   int result;
73085
73086   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
73087   jresult = (int)result;
73088   return jresult;
73089 }
73090
73091
73092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
73093   int jresult ;
73094   int result;
73095
73096   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
73097   jresult = (int)result;
73098   return jresult;
73099 }
73100
73101
73102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
73103   int jresult ;
73104   int result;
73105
73106   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
73107   jresult = (int)result;
73108   return jresult;
73109 }
73110
73111
73112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
73113   int jresult ;
73114   int result;
73115
73116   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
73117   jresult = (int)result;
73118   return jresult;
73119 }
73120
73121
73122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
73123   int jresult ;
73124   int result;
73125
73126   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
73127   jresult = (int)result;
73128   return jresult;
73129 }
73130
73131
73132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
73133   int jresult ;
73134   int result;
73135
73136   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
73137   jresult = (int)result;
73138   return jresult;
73139 }
73140
73141
73142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
73143   int jresult ;
73144   int result;
73145
73146   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
73147   jresult = (int)result;
73148   return jresult;
73149 }
73150
73151
73152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
73153   void * jresult ;
73154   Dali::Toolkit::TextEditor::Property *result = 0 ;
73155
73156   {
73157     try {
73158       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
73159     } catch (std::out_of_range& e) {
73160       {
73161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73162       };
73163     } catch (std::exception& e) {
73164       {
73165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73166       };
73167     } catch (...) {
73168       {
73169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73170       };
73171     }
73172   }
73173   jresult = (void *)result;
73174   return jresult;
73175 }
73176
73177
73178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
73179   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
73180
73181   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
73182   {
73183     try {
73184       delete arg1;
73185     } catch (std::out_of_range& e) {
73186       {
73187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73188       };
73189     } catch (std::exception& e) {
73190       {
73191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73192       };
73193     } catch (...) {
73194       {
73195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73196       };
73197     }
73198   }
73199 }
73200
73201
73202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
73203   void * jresult ;
73204   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
73205
73206   {
73207     try {
73208       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
73209     } catch (std::out_of_range& e) {
73210       {
73211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73212       };
73213     } catch (std::exception& e) {
73214       {
73215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73216       };
73217     } catch (...) {
73218       {
73219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73220       };
73221     }
73222   }
73223   jresult = (void *)result;
73224   return jresult;
73225 }
73226
73227
73228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
73229   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
73230
73231   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
73232   {
73233     try {
73234       delete arg1;
73235     } catch (std::out_of_range& e) {
73236       {
73237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73238       };
73239     } catch (std::exception& e) {
73240       {
73241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73242       };
73243     } catch (...) {
73244       {
73245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73246       };
73247     }
73248   }
73249 }
73250
73251
73252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
73253   void * jresult ;
73254   Dali::Toolkit::TextEditor result;
73255
73256   {
73257     try {
73258       result = Dali::Toolkit::TextEditor::New();
73259     } catch (std::out_of_range& e) {
73260       {
73261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73262       };
73263     } catch (std::exception& e) {
73264       {
73265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73266       };
73267     } catch (...) {
73268       {
73269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73270       };
73271     }
73272   }
73273   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
73274   return jresult;
73275 }
73276
73277
73278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
73279   void * jresult ;
73280   Dali::Toolkit::TextEditor *result = 0 ;
73281
73282   {
73283     try {
73284       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
73285     } catch (std::out_of_range& e) {
73286       {
73287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73288       };
73289     } catch (std::exception& e) {
73290       {
73291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73292       };
73293     } catch (...) {
73294       {
73295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73296       };
73297     }
73298   }
73299   jresult = (void *)result;
73300   return jresult;
73301 }
73302
73303
73304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
73305   void * jresult ;
73306   Dali::Toolkit::TextEditor *arg1 = 0 ;
73307   Dali::Toolkit::TextEditor *result = 0 ;
73308
73309   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
73310   if (!arg1) {
73311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
73312     return 0;
73313   }
73314   {
73315     try {
73316       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
73317     } catch (std::out_of_range& e) {
73318       {
73319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73320       };
73321     } catch (std::exception& e) {
73322       {
73323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73324       };
73325     } catch (...) {
73326       {
73327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73328       };
73329     }
73330   }
73331   jresult = (void *)result;
73332   return jresult;
73333 }
73334
73335
73336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
73337   void * jresult ;
73338   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
73339   Dali::Toolkit::TextEditor *arg2 = 0 ;
73340   Dali::Toolkit::TextEditor *result = 0 ;
73341
73342   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
73343   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
73344   if (!arg2) {
73345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
73346     return 0;
73347   }
73348   {
73349     try {
73350       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
73351     } catch (std::out_of_range& e) {
73352       {
73353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73354       };
73355     } catch (std::exception& e) {
73356       {
73357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73358       };
73359     } catch (...) {
73360       {
73361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73362       };
73363     }
73364   }
73365   jresult = (void *)result;
73366   return jresult;
73367 }
73368
73369
73370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
73371   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
73372
73373   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
73374   {
73375     try {
73376       delete arg1;
73377     } catch (std::out_of_range& e) {
73378       {
73379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73380       };
73381     } catch (std::exception& e) {
73382       {
73383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73384       };
73385     } catch (...) {
73386       {
73387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73388       };
73389     }
73390   }
73391 }
73392
73393
73394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
73395   void * jresult ;
73396   Dali::BaseHandle arg1 ;
73397   Dali::BaseHandle *argp1 ;
73398   Dali::Toolkit::TextEditor result;
73399
73400   argp1 = (Dali::BaseHandle *)jarg1;
73401   if (!argp1) {
73402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73403     return 0;
73404   }
73405   arg1 = *argp1;
73406   {
73407     try {
73408       result = Dali::Toolkit::TextEditor::DownCast(arg1);
73409     } catch (std::out_of_range& e) {
73410       {
73411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73412       };
73413     } catch (std::exception& e) {
73414       {
73415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73416       };
73417     } catch (...) {
73418       {
73419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73420       };
73421     }
73422   }
73423   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
73424   return jresult;
73425 }
73426
73427
73428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
73429   void * jresult ;
73430   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
73431   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
73432
73433   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
73434   {
73435     try {
73436       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
73437     } catch (std::out_of_range& e) {
73438       {
73439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73440       };
73441     } catch (std::exception& e) {
73442       {
73443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73444       };
73445     } catch (...) {
73446       {
73447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73448       };
73449     }
73450   }
73451   jresult = (void *)result;
73452   return jresult;
73453 }
73454
73455
73456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
73457   void * jresult ;
73458   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
73459   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
73460
73461   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
73462   {
73463     try {
73464       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
73465     } catch (std::out_of_range& e) {
73466       {
73467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73468       };
73469     } catch (std::exception& e) {
73470       {
73471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73472       };
73473     } catch (...) {
73474       {
73475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73476       };
73477     }
73478   }
73479   jresult = (void *)result;
73480   return jresult;
73481 }
73482
73483
73484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
73485   int jresult ;
73486   int result;
73487
73488   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
73489   jresult = (int)result;
73490   return jresult;
73491 }
73492
73493
73494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
73495   int jresult ;
73496   int result;
73497
73498   result = (int)Dali::Toolkit::TextField::Property::TEXT;
73499   jresult = (int)result;
73500   return jresult;
73501 }
73502
73503
73504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
73505   int jresult ;
73506   int result;
73507
73508   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
73509   jresult = (int)result;
73510   return jresult;
73511 }
73512
73513
73514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
73515   int jresult ;
73516   int result;
73517
73518   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
73519   jresult = (int)result;
73520   return jresult;
73521 }
73522
73523
73524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
73525   int jresult ;
73526   int result;
73527
73528   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
73529   jresult = (int)result;
73530   return jresult;
73531 }
73532
73533
73534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
73535   int jresult ;
73536   int result;
73537
73538   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
73539   jresult = (int)result;
73540   return jresult;
73541 }
73542
73543
73544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
73545   int jresult ;
73546   int result;
73547
73548   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
73549   jresult = (int)result;
73550   return jresult;
73551 }
73552
73553
73554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
73555   int jresult ;
73556   int result;
73557
73558   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
73559   jresult = (int)result;
73560   return jresult;
73561 }
73562
73563
73564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
73565   int jresult ;
73566   int result;
73567
73568   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
73569   jresult = (int)result;
73570   return jresult;
73571 }
73572
73573
73574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
73575   int jresult ;
73576   int result;
73577
73578   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
73579   jresult = (int)result;
73580   return jresult;
73581 }
73582
73583
73584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
73585   int jresult ;
73586   int result;
73587
73588   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
73589   jresult = (int)result;
73590   return jresult;
73591 }
73592
73593
73594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
73595   int jresult ;
73596   int result;
73597
73598   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
73599   jresult = (int)result;
73600   return jresult;
73601 }
73602
73603
73604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
73605   int jresult ;
73606   int result;
73607
73608   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
73609   jresult = (int)result;
73610   return jresult;
73611 }
73612
73613
73614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
73615   int jresult ;
73616   int result;
73617
73618   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
73619   jresult = (int)result;
73620   return jresult;
73621 }
73622
73623
73624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
73625   int jresult ;
73626   int result;
73627
73628   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
73629   jresult = (int)result;
73630   return jresult;
73631 }
73632
73633
73634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
73635   int jresult ;
73636   int result;
73637
73638   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
73639   jresult = (int)result;
73640   return jresult;
73641 }
73642
73643
73644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
73645   int jresult ;
73646   int result;
73647
73648   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
73649   jresult = (int)result;
73650   return jresult;
73651 }
73652
73653
73654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
73655   int jresult ;
73656   int result;
73657
73658   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
73659   jresult = (int)result;
73660   return jresult;
73661 }
73662
73663
73664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
73665   int jresult ;
73666   int result;
73667
73668   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
73669   jresult = (int)result;
73670   return jresult;
73671 }
73672
73673
73674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
73675   int jresult ;
73676   int result;
73677
73678   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
73679   jresult = (int)result;
73680   return jresult;
73681 }
73682
73683
73684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
73685   int jresult ;
73686   int result;
73687
73688   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
73689   jresult = (int)result;
73690   return jresult;
73691 }
73692
73693
73694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
73695   int jresult ;
73696   int result;
73697
73698   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
73699   jresult = (int)result;
73700   return jresult;
73701 }
73702
73703
73704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
73705   int jresult ;
73706   int result;
73707
73708   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
73709   jresult = (int)result;
73710   return jresult;
73711 }
73712
73713
73714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
73715   int jresult ;
73716   int result;
73717
73718   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
73719   jresult = (int)result;
73720   return jresult;
73721 }
73722
73723
73724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
73725   int jresult ;
73726   int result;
73727
73728   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
73729   jresult = (int)result;
73730   return jresult;
73731 }
73732
73733
73734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
73735   int jresult ;
73736   int result;
73737
73738   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
73739   jresult = (int)result;
73740   return jresult;
73741 }
73742
73743
73744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
73745   int jresult ;
73746   int result;
73747
73748   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
73749   jresult = (int)result;
73750   return jresult;
73751 }
73752
73753
73754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
73755   int jresult ;
73756   int result;
73757
73758   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
73759   jresult = (int)result;
73760   return jresult;
73761 }
73762
73763
73764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
73765   int jresult ;
73766   int result;
73767
73768   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
73769   jresult = (int)result;
73770   return jresult;
73771 }
73772
73773
73774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
73775   int jresult ;
73776   int result;
73777
73778   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
73779   jresult = (int)result;
73780   return jresult;
73781 }
73782
73783
73784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
73785   int jresult ;
73786   int result;
73787
73788   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
73789   jresult = (int)result;
73790   return jresult;
73791 }
73792
73793
73794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
73795   int jresult ;
73796   int result;
73797
73798   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
73799   jresult = (int)result;
73800   return jresult;
73801 }
73802
73803
73804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
73805   int jresult ;
73806   int result;
73807
73808   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
73809   jresult = (int)result;
73810   return jresult;
73811 }
73812
73813
73814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
73815   int jresult ;
73816   int result;
73817
73818   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
73819   jresult = (int)result;
73820   return jresult;
73821 }
73822
73823
73824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
73825   int jresult ;
73826   int result;
73827
73828   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
73829   jresult = (int)result;
73830   return jresult;
73831 }
73832
73833
73834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
73835   int jresult ;
73836   int result;
73837
73838   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
73839   jresult = (int)result;
73840   return jresult;
73841 }
73842
73843
73844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
73845   int jresult ;
73846   int result;
73847
73848   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
73849   jresult = (int)result;
73850   return jresult;
73851 }
73852
73853
73854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
73855   int jresult ;
73856   int result;
73857
73858   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
73859   jresult = (int)result;
73860   return jresult;
73861 }
73862
73863
73864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
73865   int jresult ;
73866   int result;
73867
73868   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
73869   jresult = (int)result;
73870   return jresult;
73871 }
73872
73873
73874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
73875   int jresult ;
73876   int result;
73877
73878   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
73879   jresult = (int)result;
73880   return jresult;
73881 }
73882
73883
73884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
73885   int jresult ;
73886   int result;
73887
73888   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
73889   jresult = (int)result;
73890   return jresult;
73891 }
73892
73893
73894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
73895   int jresult ;
73896   int result;
73897
73898   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
73899   jresult = (int)result;
73900   return jresult;
73901 }
73902
73903
73904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
73905   int jresult ;
73906   int result;
73907
73908   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
73909   jresult = (int)result;
73910   return jresult;
73911 }
73912
73913
73914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
73915   int jresult ;
73916   int result;
73917
73918   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
73919   jresult = (int)result;
73920   return jresult;
73921 }
73922
73923
73924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
73925   int jresult ;
73926   int result;
73927
73928   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
73929   jresult = (int)result;
73930   return jresult;
73931 }
73932
73933
73934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
73935   int jresult ;
73936   int result;
73937
73938   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
73939   jresult = (int)result;
73940   return jresult;
73941 }
73942
73943
73944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
73945   int jresult ;
73946   int result;
73947
73948   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
73949   jresult = (int)result;
73950   return jresult;
73951 }
73952
73953
73954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
73955   void * jresult ;
73956   Dali::Toolkit::TextField::Property *result = 0 ;
73957
73958   {
73959     try {
73960       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
73961     } catch (std::out_of_range& e) {
73962       {
73963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73964       };
73965     } catch (std::exception& e) {
73966       {
73967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73968       };
73969     } catch (...) {
73970       {
73971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73972       };
73973     }
73974   }
73975   jresult = (void *)result;
73976   return jresult;
73977 }
73978
73979
73980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
73981   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
73982
73983   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
73984   {
73985     try {
73986       delete arg1;
73987     } catch (std::out_of_range& e) {
73988       {
73989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73990       };
73991     } catch (std::exception& e) {
73992       {
73993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73994       };
73995     } catch (...) {
73996       {
73997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73998       };
73999     }
74000   }
74001 }
74002
74003
74004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
74005   void * jresult ;
74006   Dali::Toolkit::TextField::InputStyle *result = 0 ;
74007
74008   {
74009     try {
74010       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
74011     } catch (std::out_of_range& e) {
74012       {
74013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74014       };
74015     } catch (std::exception& e) {
74016       {
74017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74018       };
74019     } catch (...) {
74020       {
74021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74022       };
74023     }
74024   }
74025   jresult = (void *)result;
74026   return jresult;
74027 }
74028
74029
74030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
74031   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
74032
74033   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
74034   {
74035     try {
74036       delete arg1;
74037     } catch (std::out_of_range& e) {
74038       {
74039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74040       };
74041     } catch (std::exception& e) {
74042       {
74043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74044       };
74045     } catch (...) {
74046       {
74047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74048       };
74049     }
74050   }
74051 }
74052
74053
74054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
74055   void * jresult ;
74056   Dali::Toolkit::TextField result;
74057
74058   {
74059     try {
74060       result = Dali::Toolkit::TextField::New();
74061     } catch (std::out_of_range& e) {
74062       {
74063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74064       };
74065     } catch (std::exception& e) {
74066       {
74067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74068       };
74069     } catch (...) {
74070       {
74071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74072       };
74073     }
74074   }
74075   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
74076   return jresult;
74077 }
74078
74079
74080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
74081   void * jresult ;
74082   Dali::Toolkit::TextField *result = 0 ;
74083
74084   {
74085     try {
74086       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
74087     } catch (std::out_of_range& e) {
74088       {
74089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74090       };
74091     } catch (std::exception& e) {
74092       {
74093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74094       };
74095     } catch (...) {
74096       {
74097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74098       };
74099     }
74100   }
74101   jresult = (void *)result;
74102   return jresult;
74103 }
74104
74105
74106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
74107   void * jresult ;
74108   Dali::Toolkit::TextField *arg1 = 0 ;
74109   Dali::Toolkit::TextField *result = 0 ;
74110
74111   arg1 = (Dali::Toolkit::TextField *)jarg1;
74112   if (!arg1) {
74113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
74114     return 0;
74115   }
74116   {
74117     try {
74118       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
74119     } catch (std::out_of_range& e) {
74120       {
74121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74122       };
74123     } catch (std::exception& e) {
74124       {
74125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74126       };
74127     } catch (...) {
74128       {
74129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74130       };
74131     }
74132   }
74133   jresult = (void *)result;
74134   return jresult;
74135 }
74136
74137
74138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
74139   void * jresult ;
74140   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
74141   Dali::Toolkit::TextField *arg2 = 0 ;
74142   Dali::Toolkit::TextField *result = 0 ;
74143
74144   arg1 = (Dali::Toolkit::TextField *)jarg1;
74145   arg2 = (Dali::Toolkit::TextField *)jarg2;
74146   if (!arg2) {
74147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
74148     return 0;
74149   }
74150   {
74151     try {
74152       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
74153     } catch (std::out_of_range& e) {
74154       {
74155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74156       };
74157     } catch (std::exception& e) {
74158       {
74159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74160       };
74161     } catch (...) {
74162       {
74163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74164       };
74165     }
74166   }
74167   jresult = (void *)result;
74168   return jresult;
74169 }
74170
74171
74172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
74173   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
74174
74175   arg1 = (Dali::Toolkit::TextField *)jarg1;
74176   {
74177     try {
74178       delete arg1;
74179     } catch (std::out_of_range& e) {
74180       {
74181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74182       };
74183     } catch (std::exception& e) {
74184       {
74185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74186       };
74187     } catch (...) {
74188       {
74189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74190       };
74191     }
74192   }
74193 }
74194
74195
74196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
74197   void * jresult ;
74198   Dali::BaseHandle arg1 ;
74199   Dali::BaseHandle *argp1 ;
74200   Dali::Toolkit::TextField result;
74201
74202   argp1 = (Dali::BaseHandle *)jarg1;
74203   if (!argp1) {
74204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74205     return 0;
74206   }
74207   arg1 = *argp1;
74208   {
74209     try {
74210       result = Dali::Toolkit::TextField::DownCast(arg1);
74211     } catch (std::out_of_range& e) {
74212       {
74213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74214       };
74215     } catch (std::exception& e) {
74216       {
74217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74218       };
74219     } catch (...) {
74220       {
74221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74222       };
74223     }
74224   }
74225   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
74226   return jresult;
74227 }
74228
74229
74230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
74231   void * jresult ;
74232   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
74233   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
74234
74235   arg1 = (Dali::Toolkit::TextField *)jarg1;
74236   {
74237     try {
74238       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
74239     } catch (std::out_of_range& e) {
74240       {
74241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74242       };
74243     } catch (std::exception& e) {
74244       {
74245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74246       };
74247     } catch (...) {
74248       {
74249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74250       };
74251     }
74252   }
74253   jresult = (void *)result;
74254   return jresult;
74255 }
74256
74257
74258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
74259   void * jresult ;
74260   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
74261   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
74262
74263   arg1 = (Dali::Toolkit::TextField *)jarg1;
74264   {
74265     try {
74266       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
74267     } catch (std::out_of_range& e) {
74268       {
74269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74270       };
74271     } catch (std::exception& e) {
74272       {
74273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74274       };
74275     } catch (...) {
74276       {
74277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74278       };
74279     }
74280   }
74281   jresult = (void *)result;
74282   return jresult;
74283 }
74284
74285
74286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
74287   void * jresult ;
74288   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
74289   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
74290
74291   arg1 = (Dali::Toolkit::TextField *)jarg1;
74292   {
74293     try {
74294       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
74295     } catch (std::out_of_range& e) {
74296       {
74297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74298       };
74299     } catch (std::exception& e) {
74300       {
74301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74302       };
74303     } catch (...) {
74304       {
74305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74306       };
74307     }
74308   }
74309   jresult = (void *)result;
74310   return jresult;
74311 }
74312
74313
74314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
74315   int jresult ;
74316   int result;
74317
74318   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
74319   jresult = (int)result;
74320   return jresult;
74321 }
74322
74323
74324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
74325   int jresult ;
74326   int result;
74327
74328   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
74329   jresult = (int)result;
74330   return jresult;
74331 }
74332
74333
74334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
74335   int jresult ;
74336   int result;
74337
74338   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
74339   jresult = (int)result;
74340   return jresult;
74341 }
74342
74343
74344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
74345   int jresult ;
74346   int result;
74347
74348   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
74349   jresult = (int)result;
74350   return jresult;
74351 }
74352
74353
74354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
74355   int jresult ;
74356   int result;
74357
74358   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
74359   jresult = (int)result;
74360   return jresult;
74361 }
74362
74363
74364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
74365   int jresult ;
74366   int result;
74367
74368   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
74369   jresult = (int)result;
74370   return jresult;
74371 }
74372
74373
74374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
74375   int jresult ;
74376   int result;
74377
74378   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
74379   jresult = (int)result;
74380   return jresult;
74381 }
74382
74383
74384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
74385   int jresult ;
74386   int result;
74387
74388   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
74389   jresult = (int)result;
74390   return jresult;
74391 }
74392
74393
74394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
74395   int jresult ;
74396   int result;
74397
74398   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
74399   jresult = (int)result;
74400   return jresult;
74401 }
74402
74403
74404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
74405   int jresult ;
74406   int result;
74407
74408   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
74409   jresult = (int)result;
74410   return jresult;
74411 }
74412
74413
74414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
74415   int jresult ;
74416   int result;
74417
74418   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
74419   jresult = (int)result;
74420   return jresult;
74421 }
74422
74423
74424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
74425   int jresult ;
74426   int result;
74427
74428   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
74429   jresult = (int)result;
74430   return jresult;
74431 }
74432
74433
74434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
74435   int jresult ;
74436   int result;
74437
74438   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
74439   jresult = (int)result;
74440   return jresult;
74441 }
74442
74443
74444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
74445   int jresult ;
74446   int result;
74447
74448   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
74449   jresult = (int)result;
74450   return jresult;
74451 }
74452
74453
74454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
74455   int jresult ;
74456   int result;
74457
74458   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
74459   jresult = (int)result;
74460   return jresult;
74461 }
74462
74463
74464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
74465   int jresult ;
74466   int result;
74467
74468   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
74469   jresult = (int)result;
74470   return jresult;
74471 }
74472
74473
74474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
74475   int jresult ;
74476   int result;
74477
74478   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
74479   jresult = (int)result;
74480   return jresult;
74481 }
74482
74483
74484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
74485   int jresult ;
74486   int result;
74487
74488   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
74489   jresult = (int)result;
74490   return jresult;
74491 }
74492
74493
74494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
74495   int jresult ;
74496   int result;
74497
74498   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
74499   jresult = (int)result;
74500   return jresult;
74501 }
74502
74503
74504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
74505   int jresult ;
74506   int result;
74507
74508   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
74509   jresult = (int)result;
74510   return jresult;
74511 }
74512
74513
74514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
74515   int jresult ;
74516   int result;
74517
74518   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
74519   jresult = (int)result;
74520   return jresult;
74521 }
74522
74523
74524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
74525   int jresult ;
74526   int result;
74527
74528   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
74529   jresult = (int)result;
74530   return jresult;
74531 }
74532
74533
74534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
74535   int jresult ;
74536   int result;
74537
74538   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
74539   jresult = (int)result;
74540   return jresult;
74541 }
74542
74543
74544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
74545   int jresult ;
74546   int result;
74547
74548   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
74549   jresult = (int)result;
74550   return jresult;
74551 }
74552
74553
74554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
74555   void * jresult ;
74556   Dali::Toolkit::TextLabel::Property *result = 0 ;
74557
74558   {
74559     try {
74560       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
74561     } catch (std::out_of_range& e) {
74562       {
74563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74564       };
74565     } catch (std::exception& e) {
74566       {
74567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74568       };
74569     } catch (...) {
74570       {
74571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74572       };
74573     }
74574   }
74575   jresult = (void *)result;
74576   return jresult;
74577 }
74578
74579
74580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
74581   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
74582
74583   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
74584   {
74585     try {
74586       delete arg1;
74587     } catch (std::out_of_range& e) {
74588       {
74589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74590       };
74591     } catch (std::exception& e) {
74592       {
74593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74594       };
74595     } catch (...) {
74596       {
74597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74598       };
74599     }
74600   }
74601 }
74602
74603
74604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
74605   void * jresult ;
74606   Dali::Toolkit::TextLabel result;
74607
74608   {
74609     try {
74610       result = Dali::Toolkit::TextLabel::New();
74611     } catch (std::out_of_range& e) {
74612       {
74613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74614       };
74615     } catch (std::exception& e) {
74616       {
74617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74618       };
74619     } catch (...) {
74620       {
74621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74622       };
74623     }
74624   }
74625   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
74626   return jresult;
74627 }
74628
74629
74630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
74631   void * jresult ;
74632   std::string *arg1 = 0 ;
74633   Dali::Toolkit::TextLabel result;
74634
74635   if (!jarg1) {
74636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74637     return 0;
74638   }
74639   std::string arg1_str(jarg1);
74640   arg1 = &arg1_str;
74641   {
74642     try {
74643       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
74644     } catch (std::out_of_range& e) {
74645       {
74646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74647       };
74648     } catch (std::exception& e) {
74649       {
74650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74651       };
74652     } catch (...) {
74653       {
74654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74655       };
74656     }
74657   }
74658   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
74659
74660   //argout typemap for const std::string&
74661
74662   return jresult;
74663 }
74664
74665
74666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
74667   void * jresult ;
74668   Dali::Toolkit::TextLabel *result = 0 ;
74669
74670   {
74671     try {
74672       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
74673     } catch (std::out_of_range& e) {
74674       {
74675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74676       };
74677     } catch (std::exception& e) {
74678       {
74679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74680       };
74681     } catch (...) {
74682       {
74683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74684       };
74685     }
74686   }
74687   jresult = (void *)result;
74688   return jresult;
74689 }
74690
74691
74692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
74693   void * jresult ;
74694   Dali::Toolkit::TextLabel *arg1 = 0 ;
74695   Dali::Toolkit::TextLabel *result = 0 ;
74696
74697   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
74698   if (!arg1) {
74699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
74700     return 0;
74701   }
74702   {
74703     try {
74704       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
74705     } catch (std::out_of_range& e) {
74706       {
74707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74708       };
74709     } catch (std::exception& e) {
74710       {
74711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74712       };
74713     } catch (...) {
74714       {
74715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74716       };
74717     }
74718   }
74719   jresult = (void *)result;
74720   return jresult;
74721 }
74722
74723
74724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
74725   void * jresult ;
74726   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
74727   Dali::Toolkit::TextLabel *arg2 = 0 ;
74728   Dali::Toolkit::TextLabel *result = 0 ;
74729
74730   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
74731   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
74732   if (!arg2) {
74733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
74734     return 0;
74735   }
74736   {
74737     try {
74738       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
74739     } catch (std::out_of_range& e) {
74740       {
74741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74742       };
74743     } catch (std::exception& e) {
74744       {
74745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74746       };
74747     } catch (...) {
74748       {
74749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74750       };
74751     }
74752   }
74753   jresult = (void *)result;
74754   return jresult;
74755 }
74756
74757
74758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
74759   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
74760
74761   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
74762   {
74763     try {
74764       delete arg1;
74765     } catch (std::out_of_range& e) {
74766       {
74767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74768       };
74769     } catch (std::exception& e) {
74770       {
74771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74772       };
74773     } catch (...) {
74774       {
74775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74776       };
74777     }
74778   }
74779 }
74780
74781
74782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
74783   void * jresult ;
74784   Dali::BaseHandle arg1 ;
74785   Dali::BaseHandle *argp1 ;
74786   Dali::Toolkit::TextLabel result;
74787
74788   argp1 = (Dali::BaseHandle *)jarg1;
74789   if (!argp1) {
74790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74791     return 0;
74792   }
74793   arg1 = *argp1;
74794   {
74795     try {
74796       result = Dali::Toolkit::TextLabel::DownCast(arg1);
74797     } catch (std::out_of_range& e) {
74798       {
74799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74800       };
74801     } catch (std::exception& e) {
74802       {
74803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74804       };
74805     } catch (...) {
74806       {
74807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74808       };
74809     }
74810   }
74811   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
74812   return jresult;
74813 }
74814
74815
74816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
74817   void * jresult ;
74818   Dali::Toolkit::AccessibilityManager *result = 0 ;
74819
74820   {
74821     try {
74822       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
74823     } catch (std::out_of_range& e) {
74824       {
74825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74826       };
74827     } catch (std::exception& e) {
74828       {
74829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74830       };
74831     } catch (...) {
74832       {
74833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74834       };
74835     }
74836   }
74837   jresult = (void *)result;
74838   return jresult;
74839 }
74840
74841
74842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
74843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74844
74845   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74846   {
74847     try {
74848       delete arg1;
74849     } catch (std::out_of_range& e) {
74850       {
74851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74852       };
74853     } catch (std::exception& e) {
74854       {
74855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74856       };
74857     } catch (...) {
74858       {
74859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74860       };
74861     }
74862   }
74863 }
74864
74865
74866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
74867   void * jresult ;
74868   Dali::Toolkit::AccessibilityManager result;
74869
74870   {
74871     try {
74872       result = Dali::Toolkit::AccessibilityManager::Get();
74873     } catch (std::out_of_range& e) {
74874       {
74875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74876       };
74877     } catch (std::exception& e) {
74878       {
74879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74880       };
74881     } catch (...) {
74882       {
74883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74884       };
74885     }
74886   }
74887   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
74888   return jresult;
74889 }
74890
74891
74892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
74893   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74894   Dali::Actor arg2 ;
74895   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
74896   std::string *arg4 = 0 ;
74897   Dali::Actor *argp2 ;
74898
74899   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74900   argp2 = (Dali::Actor *)jarg2;
74901   if (!argp2) {
74902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74903     return ;
74904   }
74905   arg2 = *argp2;
74906   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
74907   if (!jarg4) {
74908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74909     return ;
74910   }
74911   std::string arg4_str(jarg4);
74912   arg4 = &arg4_str;
74913   {
74914     try {
74915       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
74916     } catch (std::out_of_range& e) {
74917       {
74918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74919       };
74920     } catch (std::exception& e) {
74921       {
74922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74923       };
74924     } catch (...) {
74925       {
74926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74927       };
74928     }
74929   }
74930
74931   //argout typemap for const std::string&
74932
74933 }
74934
74935
74936 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
74937   char * jresult ;
74938   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74939   Dali::Actor arg2 ;
74940   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
74941   Dali::Actor *argp2 ;
74942   std::string result;
74943
74944   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74945   argp2 = (Dali::Actor *)jarg2;
74946   if (!argp2) {
74947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74948     return 0;
74949   }
74950   arg2 = *argp2;
74951   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
74952   {
74953     try {
74954       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
74955     } catch (std::out_of_range& e) {
74956       {
74957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74958       };
74959     } catch (std::exception& e) {
74960       {
74961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74962       };
74963     } catch (...) {
74964       {
74965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74966       };
74967     }
74968   }
74969   jresult = SWIG_csharp_string_callback((&result)->c_str());
74970   return jresult;
74971 }
74972
74973
74974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
74975   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74976   Dali::Actor arg2 ;
74977   unsigned int arg3 ;
74978   Dali::Actor *argp2 ;
74979
74980   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74981   argp2 = (Dali::Actor *)jarg2;
74982   if (!argp2) {
74983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74984     return ;
74985   }
74986   arg2 = *argp2;
74987   arg3 = (unsigned int)jarg3;
74988   {
74989     try {
74990       (arg1)->SetFocusOrder(arg2,arg3);
74991     } catch (std::out_of_range& e) {
74992       {
74993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74994       };
74995     } catch (std::exception& e) {
74996       {
74997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74998       };
74999     } catch (...) {
75000       {
75001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75002       };
75003     }
75004   }
75005 }
75006
75007
75008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
75009   unsigned int jresult ;
75010   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75011   Dali::Actor arg2 ;
75012   Dali::Actor *argp2 ;
75013   unsigned int result;
75014
75015   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75016   argp2 = (Dali::Actor *)jarg2;
75017   if (!argp2) {
75018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75019     return 0;
75020   }
75021   arg2 = *argp2;
75022   {
75023     try {
75024       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
75025     } catch (std::out_of_range& e) {
75026       {
75027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75028       };
75029     } catch (std::exception& e) {
75030       {
75031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75032       };
75033     } catch (...) {
75034       {
75035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75036       };
75037     }
75038   }
75039   jresult = result;
75040   return jresult;
75041 }
75042
75043
75044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
75045   unsigned int jresult ;
75046   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75047   unsigned int result;
75048
75049   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75050   {
75051     try {
75052       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
75053     } catch (std::out_of_range& e) {
75054       {
75055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75056       };
75057     } catch (std::exception& e) {
75058       {
75059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75060       };
75061     } catch (...) {
75062       {
75063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75064       };
75065     }
75066   }
75067   jresult = result;
75068   return jresult;
75069 }
75070
75071
75072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
75073   void * jresult ;
75074   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75075   unsigned int arg2 ;
75076   Dali::Actor result;
75077
75078   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75079   arg2 = (unsigned int)jarg2;
75080   {
75081     try {
75082       result = (arg1)->GetActorByFocusOrder(arg2);
75083     } catch (std::out_of_range& e) {
75084       {
75085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75086       };
75087     } catch (std::exception& e) {
75088       {
75089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75090       };
75091     } catch (...) {
75092       {
75093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75094       };
75095     }
75096   }
75097   jresult = new Dali::Actor((const Dali::Actor &)result);
75098   return jresult;
75099 }
75100
75101
75102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
75103   unsigned int jresult ;
75104   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75105   Dali::Actor arg2 ;
75106   Dali::Actor *argp2 ;
75107   bool result;
75108
75109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75110   argp2 = (Dali::Actor *)jarg2;
75111   if (!argp2) {
75112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75113     return 0;
75114   }
75115   arg2 = *argp2;
75116   {
75117     try {
75118       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
75119     } catch (std::out_of_range& e) {
75120       {
75121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75122       };
75123     } catch (std::exception& e) {
75124       {
75125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75126       };
75127     } catch (...) {
75128       {
75129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75130       };
75131     }
75132   }
75133   jresult = result;
75134   return jresult;
75135 }
75136
75137
75138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
75139   void * jresult ;
75140   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75141   Dali::Actor result;
75142
75143   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75144   {
75145     try {
75146       result = (arg1)->GetCurrentFocusActor();
75147     } catch (std::out_of_range& e) {
75148       {
75149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75150       };
75151     } catch (std::exception& e) {
75152       {
75153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75154       };
75155     } catch (...) {
75156       {
75157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75158       };
75159     }
75160   }
75161   jresult = new Dali::Actor((const Dali::Actor &)result);
75162   return jresult;
75163 }
75164
75165
75166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
75167   void * jresult ;
75168   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75169   Dali::Actor result;
75170
75171   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75172   {
75173     try {
75174       result = (arg1)->GetCurrentFocusGroup();
75175     } catch (std::out_of_range& e) {
75176       {
75177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75178       };
75179     } catch (std::exception& e) {
75180       {
75181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75182       };
75183     } catch (...) {
75184       {
75185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75186       };
75187     }
75188   }
75189   jresult = new Dali::Actor((const Dali::Actor &)result);
75190   return jresult;
75191 }
75192
75193
75194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
75195   unsigned int jresult ;
75196   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75197   unsigned int result;
75198
75199   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75200   {
75201     try {
75202       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
75203     } catch (std::out_of_range& e) {
75204       {
75205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75206       };
75207     } catch (std::exception& e) {
75208       {
75209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75210       };
75211     } catch (...) {
75212       {
75213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75214       };
75215     }
75216   }
75217   jresult = result;
75218   return jresult;
75219 }
75220
75221
75222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
75223   unsigned int jresult ;
75224   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75225   bool result;
75226
75227   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75228   {
75229     try {
75230       result = (bool)(arg1)->MoveFocusForward();
75231     } catch (std::out_of_range& e) {
75232       {
75233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75234       };
75235     } catch (std::exception& e) {
75236       {
75237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75238       };
75239     } catch (...) {
75240       {
75241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75242       };
75243     }
75244   }
75245   jresult = result;
75246   return jresult;
75247 }
75248
75249
75250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
75251   unsigned int jresult ;
75252   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75253   bool result;
75254
75255   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75256   {
75257     try {
75258       result = (bool)(arg1)->MoveFocusBackward();
75259     } catch (std::out_of_range& e) {
75260       {
75261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75262       };
75263     } catch (std::exception& e) {
75264       {
75265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75266       };
75267     } catch (...) {
75268       {
75269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75270       };
75271     }
75272   }
75273   jresult = result;
75274   return jresult;
75275 }
75276
75277
75278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
75279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75280
75281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75282   {
75283     try {
75284       (arg1)->ClearFocus();
75285     } catch (std::out_of_range& e) {
75286       {
75287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75288       };
75289     } catch (std::exception& e) {
75290       {
75291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75292       };
75293     } catch (...) {
75294       {
75295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75296       };
75297     }
75298   }
75299 }
75300
75301
75302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
75303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75304
75305   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75306   {
75307     try {
75308       (arg1)->Reset();
75309     } catch (std::out_of_range& e) {
75310       {
75311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75312       };
75313     } catch (std::exception& e) {
75314       {
75315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75316       };
75317     } catch (...) {
75318       {
75319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75320       };
75321     }
75322   }
75323 }
75324
75325
75326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
75327   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75328   Dali::Actor arg2 ;
75329   bool arg3 ;
75330   Dali::Actor *argp2 ;
75331
75332   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75333   argp2 = (Dali::Actor *)jarg2;
75334   if (!argp2) {
75335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75336     return ;
75337   }
75338   arg2 = *argp2;
75339   arg3 = jarg3 ? true : false;
75340   {
75341     try {
75342       (arg1)->SetFocusGroup(arg2,arg3);
75343     } catch (std::out_of_range& e) {
75344       {
75345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75346       };
75347     } catch (std::exception& e) {
75348       {
75349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75350       };
75351     } catch (...) {
75352       {
75353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75354       };
75355     }
75356   }
75357 }
75358
75359
75360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
75361   unsigned int jresult ;
75362   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75363   Dali::Actor arg2 ;
75364   Dali::Actor *argp2 ;
75365   bool result;
75366
75367   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75368   argp2 = (Dali::Actor *)jarg2;
75369   if (!argp2) {
75370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75371     return 0;
75372   }
75373   arg2 = *argp2;
75374   {
75375     try {
75376       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
75377     } catch (std::out_of_range& e) {
75378       {
75379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75380       };
75381     } catch (std::exception& e) {
75382       {
75383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75384       };
75385     } catch (...) {
75386       {
75387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75388       };
75389     }
75390   }
75391   jresult = result;
75392   return jresult;
75393 }
75394
75395
75396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
75397   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75398   bool arg2 ;
75399
75400   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75401   arg2 = jarg2 ? true : false;
75402   {
75403     try {
75404       (arg1)->SetGroupMode(arg2);
75405     } catch (std::out_of_range& e) {
75406       {
75407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75408       };
75409     } catch (std::exception& e) {
75410       {
75411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75412       };
75413     } catch (...) {
75414       {
75415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75416       };
75417     }
75418   }
75419 }
75420
75421
75422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
75423   unsigned int jresult ;
75424   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75425   bool result;
75426
75427   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75428   {
75429     try {
75430       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
75431     } catch (std::out_of_range& e) {
75432       {
75433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75434       };
75435     } catch (std::exception& e) {
75436       {
75437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75438       };
75439     } catch (...) {
75440       {
75441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75442       };
75443     }
75444   }
75445   jresult = result;
75446   return jresult;
75447 }
75448
75449
75450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
75451   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75452   bool arg2 ;
75453
75454   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75455   arg2 = jarg2 ? true : false;
75456   {
75457     try {
75458       (arg1)->SetWrapMode(arg2);
75459     } catch (std::out_of_range& e) {
75460       {
75461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75462       };
75463     } catch (std::exception& e) {
75464       {
75465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75466       };
75467     } catch (...) {
75468       {
75469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75470       };
75471     }
75472   }
75473 }
75474
75475
75476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
75477   unsigned int jresult ;
75478   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75479   bool result;
75480
75481   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75482   {
75483     try {
75484       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
75485     } catch (std::out_of_range& e) {
75486       {
75487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75488       };
75489     } catch (std::exception& e) {
75490       {
75491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75492       };
75493     } catch (...) {
75494       {
75495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75496       };
75497     }
75498   }
75499   jresult = result;
75500   return jresult;
75501 }
75502
75503
75504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
75505   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75506   Dali::Actor arg2 ;
75507   Dali::Actor *argp2 ;
75508
75509   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75510   argp2 = (Dali::Actor *)jarg2;
75511   if (!argp2) {
75512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75513     return ;
75514   }
75515   arg2 = *argp2;
75516   {
75517     try {
75518       (arg1)->SetFocusIndicatorActor(arg2);
75519     } catch (std::out_of_range& e) {
75520       {
75521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75522       };
75523     } catch (std::exception& e) {
75524       {
75525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75526       };
75527     } catch (...) {
75528       {
75529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75530       };
75531     }
75532   }
75533 }
75534
75535
75536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
75537   void * jresult ;
75538   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75539   Dali::Actor result;
75540
75541   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75542   {
75543     try {
75544       result = (arg1)->GetFocusIndicatorActor();
75545     } catch (std::out_of_range& e) {
75546       {
75547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75548       };
75549     } catch (std::exception& e) {
75550       {
75551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75552       };
75553     } catch (...) {
75554       {
75555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75556       };
75557     }
75558   }
75559   jresult = new Dali::Actor((const Dali::Actor &)result);
75560   return jresult;
75561 }
75562
75563
75564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
75565   void * jresult ;
75566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75567   Dali::Actor arg2 ;
75568   Dali::Actor *argp2 ;
75569   Dali::Actor result;
75570
75571   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75572   argp2 = (Dali::Actor *)jarg2;
75573   if (!argp2) {
75574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75575     return 0;
75576   }
75577   arg2 = *argp2;
75578   {
75579     try {
75580       result = (arg1)->GetFocusGroup(arg2);
75581     } catch (std::out_of_range& e) {
75582       {
75583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75584       };
75585     } catch (std::exception& e) {
75586       {
75587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75588       };
75589     } catch (...) {
75590       {
75591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75592       };
75593     }
75594   }
75595   jresult = new Dali::Actor((const Dali::Actor &)result);
75596   return jresult;
75597 }
75598
75599
75600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
75601   void * jresult ;
75602   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75603   Dali::Vector2 result;
75604
75605   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75606   {
75607     try {
75608       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
75609     } catch (std::out_of_range& e) {
75610       {
75611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75612       };
75613     } catch (std::exception& e) {
75614       {
75615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75616       };
75617     } catch (...) {
75618       {
75619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75620       };
75621     }
75622   }
75623   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75624   return jresult;
75625 }
75626
75627
75628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
75629   void * jresult ;
75630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75631   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
75632
75633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75634   {
75635     try {
75636       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
75637     } catch (std::out_of_range& e) {
75638       {
75639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75640       };
75641     } catch (std::exception& e) {
75642       {
75643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75644       };
75645     } catch (...) {
75646       {
75647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75648       };
75649     }
75650   }
75651   jresult = (void *)result;
75652   return jresult;
75653 }
75654
75655
75656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
75657   void * jresult ;
75658   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75659   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
75660
75661   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75662   {
75663     try {
75664       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
75665     } catch (std::out_of_range& e) {
75666       {
75667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75668       };
75669     } catch (std::exception& e) {
75670       {
75671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75672       };
75673     } catch (...) {
75674       {
75675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75676       };
75677     }
75678   }
75679   jresult = (void *)result;
75680   return jresult;
75681 }
75682
75683
75684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
75685   void * jresult ;
75686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75687   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
75688
75689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75690   {
75691     try {
75692       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
75693     } catch (std::out_of_range& e) {
75694       {
75695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75696       };
75697     } catch (std::exception& e) {
75698       {
75699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75700       };
75701     } catch (...) {
75702       {
75703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75704       };
75705     }
75706   }
75707   jresult = (void *)result;
75708   return jresult;
75709 }
75710
75711
75712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
75713   void * jresult ;
75714   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75715   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75716
75717   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75718   {
75719     try {
75720       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
75721     } catch (std::out_of_range& e) {
75722       {
75723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75724       };
75725     } catch (std::exception& e) {
75726       {
75727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75728       };
75729     } catch (...) {
75730       {
75731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75732       };
75733     }
75734   }
75735   jresult = (void *)result;
75736   return jresult;
75737 }
75738
75739
75740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
75741   void * jresult ;
75742   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75743   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75744
75745   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75746   {
75747     try {
75748       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
75749     } catch (std::out_of_range& e) {
75750       {
75751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75752       };
75753     } catch (std::exception& e) {
75754       {
75755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75756       };
75757     } catch (...) {
75758       {
75759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75760       };
75761     }
75762   }
75763   jresult = (void *)result;
75764   return jresult;
75765 }
75766
75767
75768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
75769   void * jresult ;
75770   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75771   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75772
75773   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75774   {
75775     try {
75776       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
75777     } catch (std::out_of_range& e) {
75778       {
75779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75780       };
75781     } catch (std::exception& e) {
75782       {
75783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75784       };
75785     } catch (...) {
75786       {
75787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75788       };
75789     }
75790   }
75791   jresult = (void *)result;
75792   return jresult;
75793 }
75794
75795
75796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
75797   void * jresult ;
75798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75799   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75800
75801   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75802   {
75803     try {
75804       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
75805     } catch (std::out_of_range& e) {
75806       {
75807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75808       };
75809     } catch (std::exception& e) {
75810       {
75811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75812       };
75813     } catch (...) {
75814       {
75815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75816       };
75817     }
75818   }
75819   jresult = (void *)result;
75820   return jresult;
75821 }
75822
75823
75824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
75825   void * jresult ;
75826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75827   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75828
75829   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75830   {
75831     try {
75832       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
75833     } catch (std::out_of_range& e) {
75834       {
75835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75836       };
75837     } catch (std::exception& e) {
75838       {
75839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75840       };
75841     } catch (...) {
75842       {
75843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75844       };
75845     }
75846   }
75847   jresult = (void *)result;
75848   return jresult;
75849 }
75850
75851
75852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
75853   void * jresult ;
75854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75855   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75856
75857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75858   {
75859     try {
75860       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
75861     } catch (std::out_of_range& e) {
75862       {
75863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75864       };
75865     } catch (std::exception& e) {
75866       {
75867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75868       };
75869     } catch (...) {
75870       {
75871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75872       };
75873     }
75874   }
75875   jresult = (void *)result;
75876   return jresult;
75877 }
75878
75879
75880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
75881   void * jresult ;
75882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75883   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75884
75885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75886   {
75887     try {
75888       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
75889     } catch (std::out_of_range& e) {
75890       {
75891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75892       };
75893     } catch (std::exception& e) {
75894       {
75895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75896       };
75897     } catch (...) {
75898       {
75899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75900       };
75901     }
75902   }
75903   jresult = (void *)result;
75904   return jresult;
75905 }
75906
75907
75908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
75909   void * jresult ;
75910   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75911   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75912
75913   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75914   {
75915     try {
75916       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
75917     } catch (std::out_of_range& e) {
75918       {
75919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75920       };
75921     } catch (std::exception& e) {
75922       {
75923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75924       };
75925     } catch (...) {
75926       {
75927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75928       };
75929     }
75930   }
75931   jresult = (void *)result;
75932   return jresult;
75933 }
75934
75935
75936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
75937   void * jresult ;
75938   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75939   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75940
75941   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75942   {
75943     try {
75944       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
75945     } catch (std::out_of_range& e) {
75946       {
75947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75948       };
75949     } catch (std::exception& e) {
75950       {
75951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75952       };
75953     } catch (...) {
75954       {
75955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75956       };
75957     }
75958   }
75959   jresult = (void *)result;
75960   return jresult;
75961 }
75962
75963
75964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
75965   void * jresult ;
75966   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75967   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75968
75969   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75970   {
75971     try {
75972       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
75973     } catch (std::out_of_range& e) {
75974       {
75975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75976       };
75977     } catch (std::exception& e) {
75978       {
75979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75980       };
75981     } catch (...) {
75982       {
75983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75984       };
75985     }
75986   }
75987   jresult = (void *)result;
75988   return jresult;
75989 }
75990
75991
75992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
75993   void * jresult ;
75994   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75995   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
75996
75997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75998   {
75999     try {
76000       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
76001     } catch (std::out_of_range& e) {
76002       {
76003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76004       };
76005     } catch (std::exception& e) {
76006       {
76007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76008       };
76009     } catch (...) {
76010       {
76011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76012       };
76013     }
76014   }
76015   jresult = (void *)result;
76016   return jresult;
76017 }
76018
76019
76020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
76021   void * jresult ;
76022   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76023   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76024
76025   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76026   {
76027     try {
76028       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
76029     } catch (std::out_of_range& e) {
76030       {
76031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76032       };
76033     } catch (std::exception& e) {
76034       {
76035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76036       };
76037     } catch (...) {
76038       {
76039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76040       };
76041     }
76042   }
76043   jresult = (void *)result;
76044   return jresult;
76045 }
76046
76047
76048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
76049   void * jresult ;
76050   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76051   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76052
76053   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76054   {
76055     try {
76056       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
76057     } catch (std::out_of_range& e) {
76058       {
76059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76060       };
76061     } catch (std::exception& e) {
76062       {
76063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76064       };
76065     } catch (...) {
76066       {
76067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76068       };
76069     }
76070   }
76071   jresult = (void *)result;
76072   return jresult;
76073 }
76074
76075
76076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
76077   void * jresult ;
76078   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76079   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76080
76081   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76082   {
76083     try {
76084       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
76085     } catch (std::out_of_range& e) {
76086       {
76087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76088       };
76089     } catch (std::exception& e) {
76090       {
76091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76092       };
76093     } catch (...) {
76094       {
76095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76096       };
76097     }
76098   }
76099   jresult = (void *)result;
76100   return jresult;
76101 }
76102
76103
76104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
76105   void * jresult ;
76106   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76107   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76108
76109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76110   {
76111     try {
76112       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
76113     } catch (std::out_of_range& e) {
76114       {
76115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76116       };
76117     } catch (std::exception& e) {
76118       {
76119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76120       };
76121     } catch (...) {
76122       {
76123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76124       };
76125     }
76126   }
76127   jresult = (void *)result;
76128   return jresult;
76129 }
76130
76131
76132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
76133   void * jresult ;
76134   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76135   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76136
76137   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76138   {
76139     try {
76140       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
76141     } catch (std::out_of_range& e) {
76142       {
76143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76144       };
76145     } catch (std::exception& e) {
76146       {
76147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76148       };
76149     } catch (...) {
76150       {
76151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76152       };
76153     }
76154   }
76155   jresult = (void *)result;
76156   return jresult;
76157 }
76158
76159
76160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
76161   void * jresult ;
76162   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76163   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76164
76165   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76166   {
76167     try {
76168       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
76169     } catch (std::out_of_range& e) {
76170       {
76171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76172       };
76173     } catch (std::exception& e) {
76174       {
76175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76176       };
76177     } catch (...) {
76178       {
76179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76180       };
76181     }
76182   }
76183   jresult = (void *)result;
76184   return jresult;
76185 }
76186
76187
76188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
76189   void * jresult ;
76190   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76191   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76192
76193   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76194   {
76195     try {
76196       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
76197     } catch (std::out_of_range& e) {
76198       {
76199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76200       };
76201     } catch (std::exception& e) {
76202       {
76203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76204       };
76205     } catch (...) {
76206       {
76207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76208       };
76209     }
76210   }
76211   jresult = (void *)result;
76212   return jresult;
76213 }
76214
76215
76216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
76217   void * jresult ;
76218   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76219   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76220
76221   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76222   {
76223     try {
76224       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
76225     } catch (std::out_of_range& e) {
76226       {
76227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76228       };
76229     } catch (std::exception& e) {
76230       {
76231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76232       };
76233     } catch (...) {
76234       {
76235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76236       };
76237     }
76238   }
76239   jresult = (void *)result;
76240   return jresult;
76241 }
76242
76243
76244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
76245   void * jresult ;
76246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76247   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76248
76249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76250   {
76251     try {
76252       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
76253     } catch (std::out_of_range& e) {
76254       {
76255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76256       };
76257     } catch (std::exception& e) {
76258       {
76259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76260       };
76261     } catch (...) {
76262       {
76263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76264       };
76265     }
76266   }
76267   jresult = (void *)result;
76268   return jresult;
76269 }
76270
76271
76272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
76273   void * jresult ;
76274   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76275   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76276
76277   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76278   {
76279     try {
76280       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
76281     } catch (std::out_of_range& e) {
76282       {
76283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76284       };
76285     } catch (std::exception& e) {
76286       {
76287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76288       };
76289     } catch (...) {
76290       {
76291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76292       };
76293     }
76294   }
76295   jresult = (void *)result;
76296   return jresult;
76297 }
76298
76299
76300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
76301   void * jresult ;
76302   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76303   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76304
76305   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76306   {
76307     try {
76308       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
76309     } catch (std::out_of_range& e) {
76310       {
76311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76312       };
76313     } catch (std::exception& e) {
76314       {
76315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76316       };
76317     } catch (...) {
76318       {
76319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76320       };
76321     }
76322   }
76323   jresult = (void *)result;
76324   return jresult;
76325 }
76326
76327
76328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
76329   void * jresult ;
76330   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76331   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76332
76333   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76334   {
76335     try {
76336       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
76337     } catch (std::out_of_range& e) {
76338       {
76339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76340       };
76341     } catch (std::exception& e) {
76342       {
76343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76344       };
76345     } catch (...) {
76346       {
76347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76348       };
76349     }
76350   }
76351   jresult = (void *)result;
76352   return jresult;
76353 }
76354
76355
76356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
76357   void * jresult ;
76358   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76359   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76360
76361   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76362   {
76363     try {
76364       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
76365     } catch (std::out_of_range& e) {
76366       {
76367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76368       };
76369     } catch (std::exception& e) {
76370       {
76371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76372       };
76373     } catch (...) {
76374       {
76375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76376       };
76377     }
76378   }
76379   jresult = (void *)result;
76380   return jresult;
76381 }
76382
76383
76384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
76385   void * jresult ;
76386   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76387   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76388
76389   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76390   {
76391     try {
76392       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
76393     } catch (std::out_of_range& e) {
76394       {
76395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76396       };
76397     } catch (std::exception& e) {
76398       {
76399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76400       };
76401     } catch (...) {
76402       {
76403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76404       };
76405     }
76406   }
76407   jresult = (void *)result;
76408   return jresult;
76409 }
76410
76411
76412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
76413   void * jresult ;
76414   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76415   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76416
76417   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76418   {
76419     try {
76420       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
76421     } catch (std::out_of_range& e) {
76422       {
76423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76424       };
76425     } catch (std::exception& e) {
76426       {
76427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76428       };
76429     } catch (...) {
76430       {
76431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76432       };
76433     }
76434   }
76435   jresult = (void *)result;
76436   return jresult;
76437 }
76438
76439
76440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
76441   void * jresult ;
76442   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76443   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
76444
76445   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76446   {
76447     try {
76448       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
76449     } catch (std::out_of_range& e) {
76450       {
76451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76452       };
76453     } catch (std::exception& e) {
76454       {
76455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76456       };
76457     } catch (...) {
76458       {
76459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76460       };
76461     }
76462   }
76463   jresult = (void *)result;
76464   return jresult;
76465 }
76466
76467
76468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
76469   void * jresult ;
76470   Dali::Toolkit::StyleManager *result = 0 ;
76471
76472   {
76473     try {
76474       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
76475     } catch (std::out_of_range& e) {
76476       {
76477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76478       };
76479     } catch (std::exception& e) {
76480       {
76481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76482       };
76483     } catch (...) {
76484       {
76485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76486       };
76487     }
76488   }
76489   jresult = (void *)result;
76490   return jresult;
76491 }
76492
76493
76494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
76495   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76496
76497   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76498   {
76499     try {
76500       delete arg1;
76501     } catch (std::out_of_range& e) {
76502       {
76503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76504       };
76505     } catch (std::exception& e) {
76506       {
76507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76508       };
76509     } catch (...) {
76510       {
76511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76512       };
76513     }
76514   }
76515 }
76516
76517
76518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
76519   void * jresult ;
76520   Dali::Toolkit::StyleManager result;
76521
76522   {
76523     try {
76524       result = Dali::Toolkit::StyleManager::Get();
76525     } catch (std::out_of_range& e) {
76526       {
76527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76528       };
76529     } catch (std::exception& e) {
76530       {
76531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76532       };
76533     } catch (...) {
76534       {
76535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76536       };
76537     }
76538   }
76539   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
76540   return jresult;
76541 }
76542
76543
76544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
76545   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76546   std::string *arg2 = 0 ;
76547
76548   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76549   if (!jarg2) {
76550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
76551     return ;
76552   }
76553   std::string arg2_str(jarg2);
76554   arg2 = &arg2_str;
76555   {
76556     try {
76557       (arg1)->ApplyTheme((std::string const &)*arg2);
76558     } catch (std::out_of_range& e) {
76559       {
76560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76561       };
76562     } catch (std::exception& e) {
76563       {
76564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76565       };
76566     } catch (...) {
76567       {
76568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76569       };
76570     }
76571   }
76572
76573   //argout typemap for const std::string&
76574
76575 }
76576
76577
76578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
76579   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76580
76581   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76582   {
76583     try {
76584       (arg1)->ApplyDefaultTheme();
76585     } catch (std::out_of_range& e) {
76586       {
76587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76588       };
76589     } catch (std::exception& e) {
76590       {
76591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76592       };
76593     } catch (...) {
76594       {
76595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76596       };
76597     }
76598   }
76599 }
76600
76601
76602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
76603   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76604   std::string *arg2 = 0 ;
76605   Dali::Property::Value *arg3 = 0 ;
76606
76607   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76608   if (!jarg2) {
76609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
76610     return ;
76611   }
76612   std::string arg2_str(jarg2);
76613   arg2 = &arg2_str;
76614   arg3 = (Dali::Property::Value *)jarg3;
76615   if (!arg3) {
76616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
76617     return ;
76618   }
76619   {
76620     try {
76621       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
76622     } catch (std::out_of_range& e) {
76623       {
76624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76625       };
76626     } catch (std::exception& e) {
76627       {
76628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76629       };
76630     } catch (...) {
76631       {
76632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76633       };
76634     }
76635   }
76636
76637   //argout typemap for const std::string&
76638
76639 }
76640
76641
76642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
76643   unsigned int jresult ;
76644   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76645   std::string *arg2 = 0 ;
76646   Dali::Property::Value *arg3 = 0 ;
76647   bool result;
76648
76649   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76650   if (!jarg2) {
76651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
76652     return 0;
76653   }
76654   std::string arg2_str(jarg2);
76655   arg2 = &arg2_str;
76656   arg3 = (Dali::Property::Value *)jarg3;
76657   if (!arg3) {
76658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
76659     return 0;
76660   }
76661   {
76662     try {
76663       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
76664     } catch (std::out_of_range& e) {
76665       {
76666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76667       };
76668     } catch (std::exception& e) {
76669       {
76670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76671       };
76672     } catch (...) {
76673       {
76674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76675       };
76676     }
76677   }
76678   jresult = result;
76679
76680   //argout typemap for const std::string&
76681
76682   return jresult;
76683 }
76684
76685
76686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
76687   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76688   Dali::Toolkit::Control arg2 ;
76689   std::string *arg3 = 0 ;
76690   std::string *arg4 = 0 ;
76691   Dali::Toolkit::Control *argp2 ;
76692
76693   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76694   argp2 = (Dali::Toolkit::Control *)jarg2;
76695   if (!argp2) {
76696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
76697     return ;
76698   }
76699   arg2 = *argp2;
76700   if (!jarg3) {
76701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
76702     return ;
76703   }
76704   std::string arg3_str(jarg3);
76705   arg3 = &arg3_str;
76706   if (!jarg4) {
76707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
76708     return ;
76709   }
76710   std::string arg4_str(jarg4);
76711   arg4 = &arg4_str;
76712   {
76713     try {
76714       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
76715     } catch (std::out_of_range& e) {
76716       {
76717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76718       };
76719     } catch (std::exception& e) {
76720       {
76721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76722       };
76723     } catch (...) {
76724       {
76725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76726       };
76727     }
76728   }
76729
76730   //argout typemap for const std::string&
76731
76732
76733   //argout typemap for const std::string&
76734
76735 }
76736
76737
76738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
76739   void * jresult ;
76740   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76741   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
76742
76743   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76744   {
76745     try {
76746       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
76747     } catch (std::out_of_range& e) {
76748       {
76749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76750       };
76751     } catch (std::exception& e) {
76752       {
76753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76754       };
76755     } catch (...) {
76756       {
76757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76758       };
76759     }
76760   }
76761   jresult = (void *)result;
76762   return jresult;
76763 }
76764
76765
76766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
76767   int jresult ;
76768   int result;
76769
76770   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
76771   jresult = (int)result;
76772   return jresult;
76773 }
76774
76775
76776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
76777   int jresult ;
76778   int result;
76779
76780   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
76781   jresult = (int)result;
76782   return jresult;
76783 }
76784
76785
76786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
76787   int jresult ;
76788   int result;
76789
76790   result = (int)Dali::Toolkit::Slider::Property::VALUE;
76791   jresult = (int)result;
76792   return jresult;
76793 }
76794
76795
76796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
76797   int jresult ;
76798   int result;
76799
76800   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
76801   jresult = (int)result;
76802   return jresult;
76803 }
76804
76805
76806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
76807   int jresult ;
76808   int result;
76809
76810   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
76811   jresult = (int)result;
76812   return jresult;
76813 }
76814
76815
76816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
76817   int jresult ;
76818   int result;
76819
76820   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
76821   jresult = (int)result;
76822   return jresult;
76823 }
76824
76825
76826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
76827   int jresult ;
76828   int result;
76829
76830   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
76831   jresult = (int)result;
76832   return jresult;
76833 }
76834
76835
76836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
76837   int jresult ;
76838   int result;
76839
76840   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
76841   jresult = (int)result;
76842   return jresult;
76843 }
76844
76845
76846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
76847   int jresult ;
76848   int result;
76849
76850   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
76851   jresult = (int)result;
76852   return jresult;
76853 }
76854
76855
76856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
76857   int jresult ;
76858   int result;
76859
76860   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
76861   jresult = (int)result;
76862   return jresult;
76863 }
76864
76865
76866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
76867   int jresult ;
76868   int result;
76869
76870   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
76871   jresult = (int)result;
76872   return jresult;
76873 }
76874
76875
76876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
76877   int jresult ;
76878   int result;
76879
76880   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
76881   jresult = (int)result;
76882   return jresult;
76883 }
76884
76885
76886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
76887   int jresult ;
76888   int result;
76889
76890   result = (int)Dali::Toolkit::Slider::Property::MARKS;
76891   jresult = (int)result;
76892   return jresult;
76893 }
76894
76895
76896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
76897   int jresult ;
76898   int result;
76899
76900   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
76901   jresult = (int)result;
76902   return jresult;
76903 }
76904
76905
76906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
76907   int jresult ;
76908   int result;
76909
76910   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
76911   jresult = (int)result;
76912   return jresult;
76913 }
76914
76915
76916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
76917   void * jresult ;
76918   Dali::Toolkit::Slider::Property *result = 0 ;
76919
76920   {
76921     try {
76922       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
76923     } catch (std::out_of_range& e) {
76924       {
76925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76926       };
76927     } catch (std::exception& e) {
76928       {
76929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76930       };
76931     } catch (...) {
76932       {
76933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76934       };
76935     }
76936   }
76937   jresult = (void *)result;
76938   return jresult;
76939 }
76940
76941
76942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
76943   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
76944
76945   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
76946   {
76947     try {
76948       delete arg1;
76949     } catch (std::out_of_range& e) {
76950       {
76951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76952       };
76953     } catch (std::exception& e) {
76954       {
76955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76956       };
76957     } catch (...) {
76958       {
76959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76960       };
76961     }
76962   }
76963 }
76964
76965
76966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
76967   void * jresult ;
76968   Dali::Toolkit::Slider result;
76969
76970   {
76971     try {
76972       result = Dali::Toolkit::Slider::New();
76973     } catch (std::out_of_range& e) {
76974       {
76975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76976       };
76977     } catch (std::exception& e) {
76978       {
76979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76980       };
76981     } catch (...) {
76982       {
76983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76984       };
76985     }
76986   }
76987   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
76988   return jresult;
76989 }
76990
76991
76992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
76993   void * jresult ;
76994   Dali::Toolkit::Slider *result = 0 ;
76995
76996   {
76997     try {
76998       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
76999     } catch (std::out_of_range& e) {
77000       {
77001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77002       };
77003     } catch (std::exception& e) {
77004       {
77005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77006       };
77007     } catch (...) {
77008       {
77009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77010       };
77011     }
77012   }
77013   jresult = (void *)result;
77014   return jresult;
77015 }
77016
77017
77018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
77019   void * jresult ;
77020   Dali::Toolkit::Slider *arg1 = 0 ;
77021   Dali::Toolkit::Slider *result = 0 ;
77022
77023   arg1 = (Dali::Toolkit::Slider *)jarg1;
77024   if (!arg1) {
77025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
77026     return 0;
77027   }
77028   {
77029     try {
77030       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
77031     } catch (std::out_of_range& e) {
77032       {
77033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77034       };
77035     } catch (std::exception& e) {
77036       {
77037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77038       };
77039     } catch (...) {
77040       {
77041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77042       };
77043     }
77044   }
77045   jresult = (void *)result;
77046   return jresult;
77047 }
77048
77049
77050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
77051   void * jresult ;
77052   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77053   Dali::Toolkit::Slider *arg2 = 0 ;
77054   Dali::Toolkit::Slider *result = 0 ;
77055
77056   arg1 = (Dali::Toolkit::Slider *)jarg1;
77057   arg2 = (Dali::Toolkit::Slider *)jarg2;
77058   if (!arg2) {
77059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
77060     return 0;
77061   }
77062   {
77063     try {
77064       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
77065     } catch (std::out_of_range& e) {
77066       {
77067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77068       };
77069     } catch (std::exception& e) {
77070       {
77071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77072       };
77073     } catch (...) {
77074       {
77075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77076       };
77077     }
77078   }
77079   jresult = (void *)result;
77080   return jresult;
77081 }
77082
77083
77084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
77085   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77086
77087   arg1 = (Dali::Toolkit::Slider *)jarg1;
77088   {
77089     try {
77090       delete arg1;
77091     } catch (std::out_of_range& e) {
77092       {
77093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77094       };
77095     } catch (std::exception& e) {
77096       {
77097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77098       };
77099     } catch (...) {
77100       {
77101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77102       };
77103     }
77104   }
77105 }
77106
77107
77108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
77109   void * jresult ;
77110   Dali::BaseHandle arg1 ;
77111   Dali::BaseHandle *argp1 ;
77112   Dali::Toolkit::Slider result;
77113
77114   argp1 = (Dali::BaseHandle *)jarg1;
77115   if (!argp1) {
77116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77117     return 0;
77118   }
77119   arg1 = *argp1;
77120   {
77121     try {
77122       result = Dali::Toolkit::Slider::DownCast(arg1);
77123     } catch (std::out_of_range& e) {
77124       {
77125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77126       };
77127     } catch (std::exception& e) {
77128       {
77129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77130       };
77131     } catch (...) {
77132       {
77133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77134       };
77135     }
77136   }
77137   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
77138   return jresult;
77139 }
77140
77141
77142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
77143   void * jresult ;
77144   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77145   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
77146
77147   arg1 = (Dali::Toolkit::Slider *)jarg1;
77148   {
77149     try {
77150       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77151     } catch (std::out_of_range& e) {
77152       {
77153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77154       };
77155     } catch (std::exception& e) {
77156       {
77157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77158       };
77159     } catch (...) {
77160       {
77161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77162       };
77163     }
77164   }
77165   jresult = (void *)result;
77166   return jresult;
77167 }
77168
77169
77170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
77171   void * jresult ;
77172   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77173   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
77174
77175   arg1 = (Dali::Toolkit::Slider *)jarg1;
77176   {
77177     try {
77178       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
77179     } catch (std::out_of_range& e) {
77180       {
77181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77182       };
77183     } catch (std::exception& e) {
77184       {
77185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77186       };
77187     } catch (...) {
77188       {
77189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77190       };
77191     }
77192   }
77193   jresult = (void *)result;
77194   return jresult;
77195 }
77196
77197
77198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
77199   void * jresult ;
77200   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77201   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
77202
77203   arg1 = (Dali::Toolkit::Slider *)jarg1;
77204   {
77205     try {
77206       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
77207     } catch (std::out_of_range& e) {
77208       {
77209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77210       };
77211     } catch (std::exception& e) {
77212       {
77213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77214       };
77215     } catch (...) {
77216       {
77217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77218       };
77219     }
77220   }
77221   jresult = (void *)result;
77222   return jresult;
77223 }
77224
77225
77226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
77227   int jresult ;
77228   int result;
77229
77230   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
77231   jresult = (int)result;
77232   return jresult;
77233 }
77234
77235
77236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
77237   int jresult ;
77238   int result;
77239
77240   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
77241   jresult = (int)result;
77242   return jresult;
77243 }
77244
77245
77246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
77247   int jresult ;
77248   int result;
77249
77250   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
77251   jresult = (int)result;
77252   return jresult;
77253 }
77254
77255
77256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
77257   int jresult ;
77258   int result;
77259
77260   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
77261   jresult = (int)result;
77262   return jresult;
77263 }
77264
77265
77266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
77267   void * jresult ;
77268   Dali::Toolkit::VideoView::Property *result = 0 ;
77269
77270   {
77271     try {
77272       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
77273     } catch (std::out_of_range& e) {
77274       {
77275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77276       };
77277     } catch (std::exception& e) {
77278       {
77279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77280       };
77281     } catch (...) {
77282       {
77283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77284       };
77285     }
77286   }
77287   jresult = (void *)result;
77288   return jresult;
77289 }
77290
77291
77292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
77293   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
77294
77295   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
77296   {
77297     try {
77298       delete arg1;
77299     } catch (std::out_of_range& e) {
77300       {
77301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77302       };
77303     } catch (std::exception& e) {
77304       {
77305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77306       };
77307     } catch (...) {
77308       {
77309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77310       };
77311     }
77312   }
77313 }
77314
77315
77316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
77317   void * jresult ;
77318   Dali::Toolkit::VideoView result;
77319
77320   {
77321     try {
77322       result = Dali::Toolkit::VideoView::New();
77323     } catch (std::out_of_range& e) {
77324       {
77325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77326       };
77327     } catch (std::exception& e) {
77328       {
77329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77330       };
77331     } catch (...) {
77332       {
77333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77334       };
77335     }
77336   }
77337   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77338   return jresult;
77339 }
77340
77341
77342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
77343   void * jresult ;
77344   std::string *arg1 = 0 ;
77345   Dali::Toolkit::VideoView result;
77346
77347   if (!jarg1) {
77348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77349     return 0;
77350   }
77351   std::string arg1_str(jarg1);
77352   arg1 = &arg1_str;
77353   {
77354     try {
77355       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
77356     } catch (std::out_of_range& e) {
77357       {
77358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77359       };
77360     } catch (std::exception& e) {
77361       {
77362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77363       };
77364     } catch (...) {
77365       {
77366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77367       };
77368     }
77369   }
77370   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77371
77372   //argout typemap for const std::string&
77373
77374   return jresult;
77375 }
77376
77377
77378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
77379   void * jresult ;
77380   Dali::Toolkit::VideoView *result = 0 ;
77381
77382   {
77383     try {
77384       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
77385     } catch (std::out_of_range& e) {
77386       {
77387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77388       };
77389     } catch (std::exception& e) {
77390       {
77391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77392       };
77393     } catch (...) {
77394       {
77395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77396       };
77397     }
77398   }
77399   jresult = (void *)result;
77400   return jresult;
77401 }
77402
77403
77404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
77405   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77406
77407   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77408   {
77409     try {
77410       delete arg1;
77411     } catch (std::out_of_range& e) {
77412       {
77413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77414       };
77415     } catch (std::exception& e) {
77416       {
77417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77418       };
77419     } catch (...) {
77420       {
77421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77422       };
77423     }
77424   }
77425 }
77426
77427
77428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
77429   void * jresult ;
77430   Dali::Toolkit::VideoView *arg1 = 0 ;
77431   Dali::Toolkit::VideoView *result = 0 ;
77432
77433   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77434   if (!arg1) {
77435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
77436     return 0;
77437   }
77438   {
77439     try {
77440       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
77441     } catch (std::out_of_range& e) {
77442       {
77443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77444       };
77445     } catch (std::exception& e) {
77446       {
77447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77448       };
77449     } catch (...) {
77450       {
77451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77452       };
77453     }
77454   }
77455   jresult = (void *)result;
77456   return jresult;
77457 }
77458
77459
77460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
77461   void * jresult ;
77462   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77463   Dali::Toolkit::VideoView *arg2 = 0 ;
77464   Dali::Toolkit::VideoView *result = 0 ;
77465
77466   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77467   arg2 = (Dali::Toolkit::VideoView *)jarg2;
77468   if (!arg2) {
77469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
77470     return 0;
77471   }
77472   {
77473     try {
77474       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
77475     } catch (std::out_of_range& e) {
77476       {
77477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77478       };
77479     } catch (std::exception& e) {
77480       {
77481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77482       };
77483     } catch (...) {
77484       {
77485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77486       };
77487     }
77488   }
77489   jresult = (void *)result;
77490   return jresult;
77491 }
77492
77493
77494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
77495   void * jresult ;
77496   Dali::BaseHandle arg1 ;
77497   Dali::BaseHandle *argp1 ;
77498   Dali::Toolkit::VideoView result;
77499
77500   argp1 = (Dali::BaseHandle *)jarg1;
77501   if (!argp1) {
77502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77503     return 0;
77504   }
77505   arg1 = *argp1;
77506   {
77507     try {
77508       result = Dali::Toolkit::VideoView::DownCast(arg1);
77509     } catch (std::out_of_range& e) {
77510       {
77511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77512       };
77513     } catch (std::exception& e) {
77514       {
77515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77516       };
77517     } catch (...) {
77518       {
77519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77520       };
77521     }
77522   }
77523   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77524   return jresult;
77525 }
77526
77527
77528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
77529   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77530
77531   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77532   {
77533     try {
77534       (arg1)->Play();
77535     } catch (std::out_of_range& e) {
77536       {
77537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77538       };
77539     } catch (std::exception& e) {
77540       {
77541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77542       };
77543     } catch (...) {
77544       {
77545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77546       };
77547     }
77548   }
77549 }
77550
77551
77552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
77553   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77554
77555   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77556   {
77557     try {
77558       (arg1)->Pause();
77559     } catch (std::out_of_range& e) {
77560       {
77561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77562       };
77563     } catch (std::exception& e) {
77564       {
77565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77566       };
77567     } catch (...) {
77568       {
77569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77570       };
77571     }
77572   }
77573 }
77574
77575
77576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
77577   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77578
77579   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77580   {
77581     try {
77582       (arg1)->Stop();
77583     } catch (std::out_of_range& e) {
77584       {
77585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77586       };
77587     } catch (std::exception& e) {
77588       {
77589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77590       };
77591     } catch (...) {
77592       {
77593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77594       };
77595     }
77596   }
77597 }
77598
77599
77600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
77601   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77602   int arg2 ;
77603
77604   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77605   arg2 = (int)jarg2;
77606   {
77607     try {
77608       (arg1)->Forward(arg2);
77609     } catch (std::out_of_range& e) {
77610       {
77611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77612       };
77613     } catch (std::exception& e) {
77614       {
77615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77616       };
77617     } catch (...) {
77618       {
77619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77620       };
77621     }
77622   }
77623 }
77624
77625
77626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
77627   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77628   int arg2 ;
77629
77630   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77631   arg2 = (int)jarg2;
77632   {
77633     try {
77634       (arg1)->Backward(arg2);
77635     } catch (std::out_of_range& e) {
77636       {
77637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77638       };
77639     } catch (std::exception& e) {
77640       {
77641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77642       };
77643     } catch (...) {
77644       {
77645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77646       };
77647     }
77648   }
77649 }
77650
77651
77652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
77653   void * jresult ;
77654   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77655   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
77656
77657   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77658   {
77659     try {
77660       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
77661     } catch (std::out_of_range& e) {
77662       {
77663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77664       };
77665     } catch (std::exception& e) {
77666       {
77667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77668       };
77669     } catch (...) {
77670       {
77671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77672       };
77673     }
77674   }
77675   jresult = (void *)result;
77676   return jresult;
77677 }
77678
77679
77680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
77681   int jresult ;
77682   int result;
77683
77684   result = (int)Dali::Toolkit::Popup::Property::TITLE;
77685   jresult = (int)result;
77686   return jresult;
77687 }
77688
77689
77690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
77691   int jresult ;
77692   int result;
77693
77694   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
77695   jresult = (int)result;
77696   return jresult;
77697 }
77698
77699
77700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
77701   int jresult ;
77702   int result;
77703
77704   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
77705   jresult = (int)result;
77706   return jresult;
77707 }
77708
77709
77710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
77711   int jresult ;
77712   int result;
77713
77714   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
77715   jresult = (int)result;
77716   return jresult;
77717 }
77718
77719
77720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
77721   int jresult ;
77722   int result;
77723
77724   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
77725   jresult = (int)result;
77726   return jresult;
77727 }
77728
77729
77730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
77731   int jresult ;
77732   int result;
77733
77734   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
77735   jresult = (int)result;
77736   return jresult;
77737 }
77738
77739
77740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
77741   int jresult ;
77742   int result;
77743
77744   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
77745   jresult = (int)result;
77746   return jresult;
77747 }
77748
77749
77750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
77751   int jresult ;
77752   int result;
77753
77754   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
77755   jresult = (int)result;
77756   return jresult;
77757 }
77758
77759
77760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
77761   int jresult ;
77762   int result;
77763
77764   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
77765   jresult = (int)result;
77766   return jresult;
77767 }
77768
77769
77770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
77771   int jresult ;
77772   int result;
77773
77774   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
77775   jresult = (int)result;
77776   return jresult;
77777 }
77778
77779
77780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
77781   int jresult ;
77782   int result;
77783
77784   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
77785   jresult = (int)result;
77786   return jresult;
77787 }
77788
77789
77790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
77791   int jresult ;
77792   int result;
77793
77794   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
77795   jresult = (int)result;
77796   return jresult;
77797 }
77798
77799
77800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
77801   int jresult ;
77802   int result;
77803
77804   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
77805   jresult = (int)result;
77806   return jresult;
77807 }
77808
77809
77810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
77811   int jresult ;
77812   int result;
77813
77814   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
77815   jresult = (int)result;
77816   return jresult;
77817 }
77818
77819
77820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
77821   int jresult ;
77822   int result;
77823
77824   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
77825   jresult = (int)result;
77826   return jresult;
77827 }
77828
77829
77830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
77831   int jresult ;
77832   int result;
77833
77834   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
77835   jresult = (int)result;
77836   return jresult;
77837 }
77838
77839
77840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
77841   int jresult ;
77842   int result;
77843
77844   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
77845   jresult = (int)result;
77846   return jresult;
77847 }
77848
77849
77850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
77851   int jresult ;
77852   int result;
77853
77854   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
77855   jresult = (int)result;
77856   return jresult;
77857 }
77858
77859
77860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
77861   int jresult ;
77862   int result;
77863
77864   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
77865   jresult = (int)result;
77866   return jresult;
77867 }
77868
77869
77870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
77871   int jresult ;
77872   int result;
77873
77874   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
77875   jresult = (int)result;
77876   return jresult;
77877 }
77878
77879
77880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
77881   void * jresult ;
77882   Dali::Toolkit::Popup::Property *result = 0 ;
77883
77884   {
77885     try {
77886       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
77887     } catch (std::out_of_range& e) {
77888       {
77889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77890       };
77891     } catch (std::exception& e) {
77892       {
77893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77894       };
77895     } catch (...) {
77896       {
77897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77898       };
77899     }
77900   }
77901   jresult = (void *)result;
77902   return jresult;
77903 }
77904
77905
77906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
77907   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
77908
77909   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
77910   {
77911     try {
77912       delete arg1;
77913     } catch (std::out_of_range& e) {
77914       {
77915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77916       };
77917     } catch (std::exception& e) {
77918       {
77919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77920       };
77921     } catch (...) {
77922       {
77923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77924       };
77925     }
77926   }
77927 }
77928
77929
77930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
77931   void * jresult ;
77932   Dali::Toolkit::Popup *result = 0 ;
77933
77934   {
77935     try {
77936       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
77937     } catch (std::out_of_range& e) {
77938       {
77939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77940       };
77941     } catch (std::exception& e) {
77942       {
77943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77944       };
77945     } catch (...) {
77946       {
77947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77948       };
77949     }
77950   }
77951   jresult = (void *)result;
77952   return jresult;
77953 }
77954
77955
77956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
77957   void * jresult ;
77958   Dali::Toolkit::Popup result;
77959
77960   {
77961     try {
77962       result = Dali::Toolkit::Popup::New();
77963     } catch (std::out_of_range& e) {
77964       {
77965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77966       };
77967     } catch (std::exception& e) {
77968       {
77969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77970       };
77971     } catch (...) {
77972       {
77973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77974       };
77975     }
77976   }
77977   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
77978   return jresult;
77979 }
77980
77981
77982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
77983   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
77984
77985   arg1 = (Dali::Toolkit::Popup *)jarg1;
77986   {
77987     try {
77988       delete arg1;
77989     } catch (std::out_of_range& e) {
77990       {
77991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77992       };
77993     } catch (std::exception& e) {
77994       {
77995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77996       };
77997     } catch (...) {
77998       {
77999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78000       };
78001     }
78002   }
78003 }
78004
78005
78006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
78007   void * jresult ;
78008   Dali::Toolkit::Popup *arg1 = 0 ;
78009   Dali::Toolkit::Popup *result = 0 ;
78010
78011   arg1 = (Dali::Toolkit::Popup *)jarg1;
78012   if (!arg1) {
78013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
78014     return 0;
78015   }
78016   {
78017     try {
78018       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
78019     } catch (std::out_of_range& e) {
78020       {
78021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78022       };
78023     } catch (std::exception& e) {
78024       {
78025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78026       };
78027     } catch (...) {
78028       {
78029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78030       };
78031     }
78032   }
78033   jresult = (void *)result;
78034   return jresult;
78035 }
78036
78037
78038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
78039   void * jresult ;
78040   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78041   Dali::Toolkit::Popup *arg2 = 0 ;
78042   Dali::Toolkit::Popup *result = 0 ;
78043
78044   arg1 = (Dali::Toolkit::Popup *)jarg1;
78045   arg2 = (Dali::Toolkit::Popup *)jarg2;
78046   if (!arg2) {
78047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
78048     return 0;
78049   }
78050   {
78051     try {
78052       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
78053     } catch (std::out_of_range& e) {
78054       {
78055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78056       };
78057     } catch (std::exception& e) {
78058       {
78059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78060       };
78061     } catch (...) {
78062       {
78063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78064       };
78065     }
78066   }
78067   jresult = (void *)result;
78068   return jresult;
78069 }
78070
78071
78072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
78073   void * jresult ;
78074   Dali::BaseHandle arg1 ;
78075   Dali::BaseHandle *argp1 ;
78076   Dali::Toolkit::Popup result;
78077
78078   argp1 = (Dali::BaseHandle *)jarg1;
78079   if (!argp1) {
78080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78081     return 0;
78082   }
78083   arg1 = *argp1;
78084   {
78085     try {
78086       result = Dali::Toolkit::Popup::DownCast(arg1);
78087     } catch (std::out_of_range& e) {
78088       {
78089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78090       };
78091     } catch (std::exception& e) {
78092       {
78093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78094       };
78095     } catch (...) {
78096       {
78097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78098       };
78099     }
78100   }
78101   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
78102   return jresult;
78103 }
78104
78105
78106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
78107   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78108   Dali::Actor arg2 ;
78109   Dali::Actor *argp2 ;
78110
78111   arg1 = (Dali::Toolkit::Popup *)jarg1;
78112   argp2 = (Dali::Actor *)jarg2;
78113   if (!argp2) {
78114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78115     return ;
78116   }
78117   arg2 = *argp2;
78118   {
78119     try {
78120       (arg1)->SetTitle(arg2);
78121     } catch (std::out_of_range& e) {
78122       {
78123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78124       };
78125     } catch (std::exception& e) {
78126       {
78127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78128       };
78129     } catch (...) {
78130       {
78131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78132       };
78133     }
78134   }
78135 }
78136
78137
78138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
78139   void * jresult ;
78140   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78141   Dali::Actor result;
78142
78143   arg1 = (Dali::Toolkit::Popup *)jarg1;
78144   {
78145     try {
78146       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
78147     } catch (std::out_of_range& e) {
78148       {
78149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78150       };
78151     } catch (std::exception& e) {
78152       {
78153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78154       };
78155     } catch (...) {
78156       {
78157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78158       };
78159     }
78160   }
78161   jresult = new Dali::Actor((const Dali::Actor &)result);
78162   return jresult;
78163 }
78164
78165
78166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
78167   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78168   Dali::Actor arg2 ;
78169   Dali::Actor *argp2 ;
78170
78171   arg1 = (Dali::Toolkit::Popup *)jarg1;
78172   argp2 = (Dali::Actor *)jarg2;
78173   if (!argp2) {
78174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78175     return ;
78176   }
78177   arg2 = *argp2;
78178   {
78179     try {
78180       (arg1)->SetContent(arg2);
78181     } catch (std::out_of_range& e) {
78182       {
78183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78184       };
78185     } catch (std::exception& e) {
78186       {
78187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78188       };
78189     } catch (...) {
78190       {
78191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78192       };
78193     }
78194   }
78195 }
78196
78197
78198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
78199   void * jresult ;
78200   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78201   Dali::Actor result;
78202
78203   arg1 = (Dali::Toolkit::Popup *)jarg1;
78204   {
78205     try {
78206       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
78207     } catch (std::out_of_range& e) {
78208       {
78209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78210       };
78211     } catch (std::exception& e) {
78212       {
78213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78214       };
78215     } catch (...) {
78216       {
78217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78218       };
78219     }
78220   }
78221   jresult = new Dali::Actor((const Dali::Actor &)result);
78222   return jresult;
78223 }
78224
78225
78226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
78227   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78228   Dali::Actor arg2 ;
78229   Dali::Actor *argp2 ;
78230
78231   arg1 = (Dali::Toolkit::Popup *)jarg1;
78232   argp2 = (Dali::Actor *)jarg2;
78233   if (!argp2) {
78234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78235     return ;
78236   }
78237   arg2 = *argp2;
78238   {
78239     try {
78240       (arg1)->SetFooter(arg2);
78241     } catch (std::out_of_range& e) {
78242       {
78243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78244       };
78245     } catch (std::exception& e) {
78246       {
78247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78248       };
78249     } catch (...) {
78250       {
78251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78252       };
78253     }
78254   }
78255 }
78256
78257
78258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
78259   void * jresult ;
78260   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78261   Dali::Actor result;
78262
78263   arg1 = (Dali::Toolkit::Popup *)jarg1;
78264   {
78265     try {
78266       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
78267     } catch (std::out_of_range& e) {
78268       {
78269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78270       };
78271     } catch (std::exception& e) {
78272       {
78273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78274       };
78275     } catch (...) {
78276       {
78277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78278       };
78279     }
78280   }
78281   jresult = new Dali::Actor((const Dali::Actor &)result);
78282   return jresult;
78283 }
78284
78285
78286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
78287   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78288   Dali::Toolkit::Popup::DisplayState arg2 ;
78289
78290   arg1 = (Dali::Toolkit::Popup *)jarg1;
78291   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
78292   {
78293     try {
78294       (arg1)->SetDisplayState(arg2);
78295     } catch (std::out_of_range& e) {
78296       {
78297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78298       };
78299     } catch (std::exception& e) {
78300       {
78301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78302       };
78303     } catch (...) {
78304       {
78305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78306       };
78307     }
78308   }
78309 }
78310
78311
78312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
78313   int jresult ;
78314   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78315   Dali::Toolkit::Popup::DisplayState result;
78316
78317   arg1 = (Dali::Toolkit::Popup *)jarg1;
78318   {
78319     try {
78320       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
78321     } catch (std::out_of_range& e) {
78322       {
78323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78324       };
78325     } catch (std::exception& e) {
78326       {
78327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78328       };
78329     } catch (...) {
78330       {
78331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78332       };
78333     }
78334   }
78335   jresult = (int)result;
78336   return jresult;
78337 }
78338
78339
78340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
78341   void * jresult ;
78342   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78343   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
78344
78345   arg1 = (Dali::Toolkit::Popup *)jarg1;
78346   {
78347     try {
78348       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
78349     } catch (std::out_of_range& e) {
78350       {
78351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78352       };
78353     } catch (std::exception& e) {
78354       {
78355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78356       };
78357     } catch (...) {
78358       {
78359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78360       };
78361     }
78362   }
78363   jresult = (void *)result;
78364   return jresult;
78365 }
78366
78367
78368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
78369   void * jresult ;
78370   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78371   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78372
78373   arg1 = (Dali::Toolkit::Popup *)jarg1;
78374   {
78375     try {
78376       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
78377     } catch (std::out_of_range& e) {
78378       {
78379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78380       };
78381     } catch (std::exception& e) {
78382       {
78383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78384       };
78385     } catch (...) {
78386       {
78387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78388       };
78389     }
78390   }
78391   jresult = (void *)result;
78392   return jresult;
78393 }
78394
78395
78396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
78397   void * jresult ;
78398   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78399   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78400
78401   arg1 = (Dali::Toolkit::Popup *)jarg1;
78402   {
78403     try {
78404       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
78405     } catch (std::out_of_range& e) {
78406       {
78407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78408       };
78409     } catch (std::exception& e) {
78410       {
78411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78412       };
78413     } catch (...) {
78414       {
78415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78416       };
78417     }
78418   }
78419   jresult = (void *)result;
78420   return jresult;
78421 }
78422
78423
78424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
78425   void * jresult ;
78426   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78427   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78428
78429   arg1 = (Dali::Toolkit::Popup *)jarg1;
78430   {
78431     try {
78432       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
78433     } catch (std::out_of_range& e) {
78434       {
78435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78436       };
78437     } catch (std::exception& e) {
78438       {
78439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78440       };
78441     } catch (...) {
78442       {
78443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78444       };
78445     }
78446   }
78447   jresult = (void *)result;
78448   return jresult;
78449 }
78450
78451
78452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
78453   void * jresult ;
78454   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78455   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78456
78457   arg1 = (Dali::Toolkit::Popup *)jarg1;
78458   {
78459     try {
78460       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
78461     } catch (std::out_of_range& e) {
78462       {
78463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78464       };
78465     } catch (std::exception& e) {
78466       {
78467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78468       };
78469     } catch (...) {
78470       {
78471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78472       };
78473     }
78474   }
78475   jresult = (void *)result;
78476   return jresult;
78477 }
78478
78479
78480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
78481   int jresult ;
78482   int result;
78483
78484   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
78485   jresult = (int)result;
78486   return jresult;
78487 }
78488
78489
78490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
78491   int jresult ;
78492   int result;
78493
78494   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
78495   jresult = (int)result;
78496   return jresult;
78497 }
78498
78499
78500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
78501   int jresult ;
78502   int result;
78503
78504   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
78505   jresult = (int)result;
78506   return jresult;
78507 }
78508
78509
78510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
78511   void * jresult ;
78512   Dali::Toolkit::ProgressBar::Property *result = 0 ;
78513
78514   {
78515     try {
78516       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
78517     } catch (std::out_of_range& e) {
78518       {
78519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78520       };
78521     } catch (std::exception& e) {
78522       {
78523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78524       };
78525     } catch (...) {
78526       {
78527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78528       };
78529     }
78530   }
78531   jresult = (void *)result;
78532   return jresult;
78533 }
78534
78535
78536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
78537   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
78538
78539   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
78540   {
78541     try {
78542       delete arg1;
78543     } catch (std::out_of_range& e) {
78544       {
78545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78546       };
78547     } catch (std::exception& e) {
78548       {
78549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78550       };
78551     } catch (...) {
78552       {
78553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78554       };
78555     }
78556   }
78557 }
78558
78559
78560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
78561   void * jresult ;
78562   Dali::Toolkit::ProgressBar result;
78563
78564   {
78565     try {
78566       result = Dali::Toolkit::ProgressBar::New();
78567     } catch (std::out_of_range& e) {
78568       {
78569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78570       };
78571     } catch (std::exception& e) {
78572       {
78573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78574       };
78575     } catch (...) {
78576       {
78577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78578       };
78579     }
78580   }
78581   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
78582   return jresult;
78583 }
78584
78585
78586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
78587   void * jresult ;
78588   Dali::Toolkit::ProgressBar *result = 0 ;
78589
78590   {
78591     try {
78592       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
78593     } catch (std::out_of_range& e) {
78594       {
78595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78596       };
78597     } catch (std::exception& e) {
78598       {
78599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78600       };
78601     } catch (...) {
78602       {
78603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78604       };
78605     }
78606   }
78607   jresult = (void *)result;
78608   return jresult;
78609 }
78610
78611
78612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
78613   void * jresult ;
78614   Dali::Toolkit::ProgressBar *arg1 = 0 ;
78615   Dali::Toolkit::ProgressBar *result = 0 ;
78616
78617   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
78618   if (!arg1) {
78619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
78620     return 0;
78621   }
78622   {
78623     try {
78624       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
78625     } catch (std::out_of_range& e) {
78626       {
78627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78628       };
78629     } catch (std::exception& e) {
78630       {
78631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78632       };
78633     } catch (...) {
78634       {
78635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78636       };
78637     }
78638   }
78639   jresult = (void *)result;
78640   return jresult;
78641 }
78642
78643
78644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
78645   void * jresult ;
78646   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
78647   Dali::Toolkit::ProgressBar *arg2 = 0 ;
78648   Dali::Toolkit::ProgressBar *result = 0 ;
78649
78650   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
78651   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
78652   if (!arg2) {
78653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
78654     return 0;
78655   }
78656   {
78657     try {
78658       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
78659     } catch (std::out_of_range& e) {
78660       {
78661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78662       };
78663     } catch (std::exception& e) {
78664       {
78665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78666       };
78667     } catch (...) {
78668       {
78669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78670       };
78671     }
78672   }
78673   jresult = (void *)result;
78674   return jresult;
78675 }
78676
78677
78678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
78679   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
78680
78681   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
78682   {
78683     try {
78684       delete arg1;
78685     } catch (std::out_of_range& e) {
78686       {
78687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78688       };
78689     } catch (std::exception& e) {
78690       {
78691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78692       };
78693     } catch (...) {
78694       {
78695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78696       };
78697     }
78698   }
78699 }
78700
78701
78702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
78703   void * jresult ;
78704   Dali::BaseHandle arg1 ;
78705   Dali::BaseHandle *argp1 ;
78706   Dali::Toolkit::ProgressBar result;
78707
78708   argp1 = (Dali::BaseHandle *)jarg1;
78709   if (!argp1) {
78710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78711     return 0;
78712   }
78713   arg1 = *argp1;
78714   {
78715     try {
78716       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
78717     } catch (std::out_of_range& e) {
78718       {
78719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78720       };
78721     } catch (std::exception& e) {
78722       {
78723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78724       };
78725     } catch (...) {
78726       {
78727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78728       };
78729     }
78730   }
78731   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
78732   return jresult;
78733 }
78734
78735
78736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
78737   void * jresult ;
78738   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
78739   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
78740
78741   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
78742   {
78743     try {
78744       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
78745     } catch (std::out_of_range& e) {
78746       {
78747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78748       };
78749     } catch (std::exception& e) {
78750       {
78751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78752       };
78753     } catch (...) {
78754       {
78755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78756       };
78757     }
78758   }
78759   jresult = (void *)result;
78760   return jresult;
78761 }
78762
78763
78764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
78765   void * jresult ;
78766   Dali::Toolkit::GaussianBlurView *result = 0 ;
78767
78768   {
78769     try {
78770       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
78771     } catch (std::out_of_range& e) {
78772       {
78773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78774       };
78775     } catch (std::exception& e) {
78776       {
78777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78778       };
78779     } catch (...) {
78780       {
78781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78782       };
78783     }
78784   }
78785   jresult = (void *)result;
78786   return jresult;
78787 }
78788
78789
78790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
78791   void * jresult ;
78792   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
78793   Dali::Toolkit::GaussianBlurView *result = 0 ;
78794
78795   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
78796   if (!arg1) {
78797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
78798     return 0;
78799   }
78800   {
78801     try {
78802       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
78803     } catch (std::out_of_range& e) {
78804       {
78805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78806       };
78807     } catch (std::exception& e) {
78808       {
78809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78810       };
78811     } catch (...) {
78812       {
78813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78814       };
78815     }
78816   }
78817   jresult = (void *)result;
78818   return jresult;
78819 }
78820
78821
78822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
78823   void * jresult ;
78824   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
78825   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
78826   Dali::Toolkit::GaussianBlurView *result = 0 ;
78827
78828   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
78829   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
78830   if (!arg2) {
78831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
78832     return 0;
78833   }
78834   {
78835     try {
78836       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
78837     } catch (std::out_of_range& e) {
78838       {
78839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78840       };
78841     } catch (std::exception& e) {
78842       {
78843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78844       };
78845     } catch (...) {
78846       {
78847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78848       };
78849     }
78850   }
78851   jresult = (void *)result;
78852   return jresult;
78853 }
78854
78855
78856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
78857   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
78858
78859   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
78860   {
78861     try {
78862       delete arg1;
78863     } catch (std::out_of_range& e) {
78864       {
78865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78866       };
78867     } catch (std::exception& e) {
78868       {
78869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78870       };
78871     } catch (...) {
78872       {
78873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78874       };
78875     }
78876   }
78877 }
78878
78879
78880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
78881   void * jresult ;
78882   Dali::BaseHandle arg1 ;
78883   Dali::BaseHandle *argp1 ;
78884   Dali::Toolkit::GaussianBlurView result;
78885
78886   argp1 = (Dali::BaseHandle *)jarg1;
78887   if (!argp1) {
78888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78889     return 0;
78890   }
78891   arg1 = *argp1;
78892   {
78893     try {
78894       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
78895     } catch (std::out_of_range& e) {
78896       {
78897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78898       };
78899     } catch (std::exception& e) {
78900       {
78901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78902       };
78903     } catch (...) {
78904       {
78905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78906       };
78907     }
78908   }
78909   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
78910   return jresult;
78911 }
78912
78913
78914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
78915   void * jresult ;
78916   Dali::Toolkit::GaussianBlurView result;
78917
78918   {
78919     try {
78920       result = Dali::Toolkit::GaussianBlurView::New();
78921     } catch (std::out_of_range& e) {
78922       {
78923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78924       };
78925     } catch (std::exception& e) {
78926       {
78927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78928       };
78929     } catch (...) {
78930       {
78931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78932       };
78933     }
78934   }
78935   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
78936   return jresult;
78937 }
78938
78939
78940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
78941   void * jresult ;
78942   unsigned int arg1 ;
78943   float arg2 ;
78944   Dali::Pixel::Format arg3 ;
78945   float arg4 ;
78946   float arg5 ;
78947   bool arg6 ;
78948   Dali::Toolkit::GaussianBlurView result;
78949
78950   arg1 = (unsigned int)jarg1;
78951   arg2 = (float)jarg2;
78952   arg3 = (Dali::Pixel::Format)jarg3;
78953   arg4 = (float)jarg4;
78954   arg5 = (float)jarg5;
78955   arg6 = jarg6 ? true : false;
78956   {
78957     try {
78958       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
78959     } catch (std::out_of_range& e) {
78960       {
78961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78962       };
78963     } catch (std::exception& e) {
78964       {
78965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78966       };
78967     } catch (...) {
78968       {
78969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78970       };
78971     }
78972   }
78973   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
78974   return jresult;
78975 }
78976
78977
78978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
78979   void * jresult ;
78980   unsigned int arg1 ;
78981   float arg2 ;
78982   Dali::Pixel::Format arg3 ;
78983   float arg4 ;
78984   float arg5 ;
78985   Dali::Toolkit::GaussianBlurView result;
78986
78987   arg1 = (unsigned int)jarg1;
78988   arg2 = (float)jarg2;
78989   arg3 = (Dali::Pixel::Format)jarg3;
78990   arg4 = (float)jarg4;
78991   arg5 = (float)jarg5;
78992   {
78993     try {
78994       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
78995     } catch (std::out_of_range& e) {
78996       {
78997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78998       };
78999     } catch (std::exception& e) {
79000       {
79001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79002       };
79003     } catch (...) {
79004       {
79005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79006       };
79007     }
79008   }
79009   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79010   return jresult;
79011 }
79012
79013
79014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
79015   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79016   Dali::Actor arg2 ;
79017   Dali::Actor *argp2 ;
79018
79019   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79020   argp2 = (Dali::Actor *)jarg2;
79021   if (!argp2) {
79022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79023     return ;
79024   }
79025   arg2 = *argp2;
79026   {
79027     try {
79028       (arg1)->Add(arg2);
79029     } catch (std::out_of_range& e) {
79030       {
79031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79032       };
79033     } catch (std::exception& e) {
79034       {
79035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79036       };
79037     } catch (...) {
79038       {
79039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79040       };
79041     }
79042   }
79043 }
79044
79045
79046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
79047   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79048   Dali::Actor arg2 ;
79049   Dali::Actor *argp2 ;
79050
79051   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79052   argp2 = (Dali::Actor *)jarg2;
79053   if (!argp2) {
79054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79055     return ;
79056   }
79057   arg2 = *argp2;
79058   {
79059     try {
79060       (arg1)->Remove(arg2);
79061     } catch (std::out_of_range& e) {
79062       {
79063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79064       };
79065     } catch (std::exception& e) {
79066       {
79067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79068       };
79069     } catch (...) {
79070       {
79071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79072       };
79073     }
79074   }
79075 }
79076
79077
79078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
79079   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79080
79081   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79082   {
79083     try {
79084       (arg1)->Activate();
79085     } catch (std::out_of_range& e) {
79086       {
79087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79088       };
79089     } catch (std::exception& e) {
79090       {
79091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79092       };
79093     } catch (...) {
79094       {
79095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79096       };
79097     }
79098   }
79099 }
79100
79101
79102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
79103   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79104
79105   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79106   {
79107     try {
79108       (arg1)->ActivateOnce();
79109     } catch (std::out_of_range& e) {
79110       {
79111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79112       };
79113     } catch (std::exception& e) {
79114       {
79115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79116       };
79117     } catch (...) {
79118       {
79119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79120       };
79121     }
79122   }
79123 }
79124
79125
79126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
79127   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79128
79129   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79130   {
79131     try {
79132       (arg1)->Deactivate();
79133     } catch (std::out_of_range& e) {
79134       {
79135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79136       };
79137     } catch (std::exception& e) {
79138       {
79139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79140       };
79141     } catch (...) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79144       };
79145     }
79146   }
79147 }
79148
79149
79150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
79151   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79152   Dali::Image arg2 ;
79153   Dali::FrameBufferImage arg3 ;
79154   Dali::Image *argp2 ;
79155   Dali::FrameBufferImage *argp3 ;
79156
79157   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79158   argp2 = (Dali::Image *)jarg2;
79159   if (!argp2) {
79160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
79161     return ;
79162   }
79163   arg2 = *argp2;
79164   argp3 = (Dali::FrameBufferImage *)jarg3;
79165   if (!argp3) {
79166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
79167     return ;
79168   }
79169   arg3 = *argp3;
79170   {
79171     try {
79172       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
79173     } catch (std::out_of_range& e) {
79174       {
79175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79176       };
79177     } catch (std::exception& e) {
79178       {
79179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79180       };
79181     } catch (...) {
79182       {
79183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79184       };
79185     }
79186   }
79187 }
79188
79189
79190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
79191   int jresult ;
79192   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79193   Dali::Property::Index result;
79194
79195   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79196   {
79197     try {
79198       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
79199     } catch (std::out_of_range& e) {
79200       {
79201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79202       };
79203     } catch (std::exception& e) {
79204       {
79205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79206       };
79207     } catch (...) {
79208       {
79209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79210       };
79211     }
79212   }
79213   jresult = result;
79214   return jresult;
79215 }
79216
79217
79218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
79219   void * jresult ;
79220   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79221   Dali::FrameBufferImage result;
79222
79223   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79224   {
79225     try {
79226       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
79227     } catch (std::out_of_range& e) {
79228       {
79229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79230       };
79231     } catch (std::exception& e) {
79232       {
79233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79234       };
79235     } catch (...) {
79236       {
79237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79238       };
79239     }
79240   }
79241   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
79242   return jresult;
79243 }
79244
79245
79246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
79247   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79248   Dali::Vector4 *arg2 = 0 ;
79249
79250   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79251   arg2 = (Dali::Vector4 *)jarg2;
79252   if (!arg2) {
79253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
79254     return ;
79255   }
79256   {
79257     try {
79258       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
79259     } catch (std::out_of_range& e) {
79260       {
79261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79262       };
79263     } catch (std::exception& e) {
79264       {
79265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79266       };
79267     } catch (...) {
79268       {
79269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79270       };
79271     }
79272   }
79273 }
79274
79275
79276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
79277   void * jresult ;
79278   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79279   Dali::Vector4 result;
79280
79281   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79282   {
79283     try {
79284       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
79285     } catch (std::out_of_range& e) {
79286       {
79287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79288       };
79289     } catch (std::exception& e) {
79290       {
79291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79292       };
79293     } catch (...) {
79294       {
79295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79296       };
79297     }
79298   }
79299   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
79300   return jresult;
79301 }
79302
79303
79304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
79305   void * jresult ;
79306   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79307   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
79308
79309   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79310   {
79311     try {
79312       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
79313     } catch (std::out_of_range& e) {
79314       {
79315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79316       };
79317     } catch (std::exception& e) {
79318       {
79319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79320       };
79321     } catch (...) {
79322       {
79323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79324       };
79325     }
79326   }
79327   jresult = (void *)result;
79328   return jresult;
79329 }
79330
79331
79332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
79333   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79334
79335   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79336   {
79337     try {
79338       delete arg1;
79339     } catch (std::out_of_range& e) {
79340       {
79341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79342       };
79343     } catch (std::exception& e) {
79344       {
79345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79346       };
79347     } catch (...) {
79348       {
79349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79350       };
79351     }
79352   }
79353 }
79354
79355
79356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
79357   unsigned int jresult ;
79358   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79359   unsigned int result;
79360
79361   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79362   {
79363     try {
79364       result = (unsigned int)(arg1)->GetNumberOfPages();
79365     } catch (std::out_of_range& e) {
79366       {
79367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79368       };
79369     } catch (std::exception& e) {
79370       {
79371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79372       };
79373     } catch (...) {
79374       {
79375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79376       };
79377     }
79378   }
79379   jresult = result;
79380   return jresult;
79381 }
79382
79383
79384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
79385   void * jresult ;
79386   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79387   unsigned int arg2 ;
79388   Dali::Image result;
79389
79390   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79391   arg2 = (unsigned int)jarg2;
79392   {
79393     try {
79394       result = (arg1)->NewPage(arg2);
79395     } catch (std::out_of_range& e) {
79396       {
79397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79398       };
79399     } catch (std::exception& e) {
79400       {
79401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79402       };
79403     } catch (...) {
79404       {
79405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79406       };
79407     }
79408   }
79409   jresult = new Dali::Image((const Dali::Image &)result);
79410   return jresult;
79411 }
79412
79413
79414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
79415   int jresult ;
79416   int result;
79417
79418   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
79419   jresult = (int)result;
79420   return jresult;
79421 }
79422
79423
79424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
79425   int jresult ;
79426   int result;
79427
79428   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
79429   jresult = (int)result;
79430   return jresult;
79431 }
79432
79433
79434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
79435   int jresult ;
79436   int result;
79437
79438   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
79439   jresult = (int)result;
79440   return jresult;
79441 }
79442
79443
79444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
79445   void * jresult ;
79446   Dali::Toolkit::PageTurnView::Property *result = 0 ;
79447
79448   {
79449     try {
79450       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
79451     } catch (std::out_of_range& e) {
79452       {
79453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79454       };
79455     } catch (std::exception& e) {
79456       {
79457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79458       };
79459     } catch (...) {
79460       {
79461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79462       };
79463     }
79464   }
79465   jresult = (void *)result;
79466   return jresult;
79467 }
79468
79469
79470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
79471   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
79472
79473   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
79474   {
79475     try {
79476       delete arg1;
79477     } catch (std::out_of_range& e) {
79478       {
79479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79480       };
79481     } catch (std::exception& e) {
79482       {
79483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79484       };
79485     } catch (...) {
79486       {
79487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79488       };
79489     }
79490   }
79491 }
79492
79493
79494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
79495   void * jresult ;
79496   Dali::Toolkit::PageTurnView *result = 0 ;
79497
79498   {
79499     try {
79500       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
79501     } catch (std::out_of_range& e) {
79502       {
79503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79504       };
79505     } catch (std::exception& e) {
79506       {
79507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79508       };
79509     } catch (...) {
79510       {
79511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79512       };
79513     }
79514   }
79515   jresult = (void *)result;
79516   return jresult;
79517 }
79518
79519
79520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
79521   void * jresult ;
79522   Dali::Toolkit::PageTurnView *arg1 = 0 ;
79523   Dali::Toolkit::PageTurnView *result = 0 ;
79524
79525   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
79526   if (!arg1) {
79527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
79528     return 0;
79529   }
79530   {
79531     try {
79532       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
79533     } catch (std::out_of_range& e) {
79534       {
79535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79536       };
79537     } catch (std::exception& e) {
79538       {
79539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79540       };
79541     } catch (...) {
79542       {
79543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79544       };
79545     }
79546   }
79547   jresult = (void *)result;
79548   return jresult;
79549 }
79550
79551
79552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
79553   void * jresult ;
79554   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
79555   Dali::Toolkit::PageTurnView *arg2 = 0 ;
79556   Dali::Toolkit::PageTurnView *result = 0 ;
79557
79558   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
79559   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
79560   if (!arg2) {
79561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
79562     return 0;
79563   }
79564   {
79565     try {
79566       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
79567     } catch (std::out_of_range& e) {
79568       {
79569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79570       };
79571     } catch (std::exception& e) {
79572       {
79573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79574       };
79575     } catch (...) {
79576       {
79577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79578       };
79579     }
79580   }
79581   jresult = (void *)result;
79582   return jresult;
79583 }
79584
79585
79586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
79587   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
79588
79589   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
79590   {
79591     try {
79592       delete arg1;
79593     } catch (std::out_of_range& e) {
79594       {
79595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79596       };
79597     } catch (std::exception& e) {
79598       {
79599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79600       };
79601     } catch (...) {
79602       {
79603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79604       };
79605     }
79606   }
79607 }
79608
79609
79610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
79611   void * jresult ;
79612   Dali::BaseHandle arg1 ;
79613   Dali::BaseHandle *argp1 ;
79614   Dali::Toolkit::PageTurnView result;
79615
79616   argp1 = (Dali::BaseHandle *)jarg1;
79617   if (!argp1) {
79618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79619     return 0;
79620   }
79621   arg1 = *argp1;
79622   {
79623     try {
79624       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
79625     } catch (std::out_of_range& e) {
79626       {
79627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79628       };
79629     } catch (std::exception& e) {
79630       {
79631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79632       };
79633     } catch (...) {
79634       {
79635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79636       };
79637     }
79638   }
79639   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
79640   return jresult;
79641 }
79642
79643
79644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
79645   void * jresult ;
79646   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
79647   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
79648
79649   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
79650   {
79651     try {
79652       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
79653     } catch (std::out_of_range& e) {
79654       {
79655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79656       };
79657     } catch (std::exception& e) {
79658       {
79659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79660       };
79661     } catch (...) {
79662       {
79663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79664       };
79665     }
79666   }
79667   jresult = (void *)result;
79668   return jresult;
79669 }
79670
79671
79672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
79673   void * jresult ;
79674   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
79675   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
79676
79677   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
79678   {
79679     try {
79680       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
79681     } catch (std::out_of_range& e) {
79682       {
79683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79684       };
79685     } catch (std::exception& e) {
79686       {
79687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79688       };
79689     } catch (...) {
79690       {
79691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79692       };
79693     }
79694   }
79695   jresult = (void *)result;
79696   return jresult;
79697 }
79698
79699
79700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
79701   void * jresult ;
79702   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
79703   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
79704
79705   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
79706   {
79707     try {
79708       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
79709     } catch (std::out_of_range& e) {
79710       {
79711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79712       };
79713     } catch (std::exception& e) {
79714       {
79715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79716       };
79717     } catch (...) {
79718       {
79719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79720       };
79721     }
79722   }
79723   jresult = (void *)result;
79724   return jresult;
79725 }
79726
79727
79728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
79729   void * jresult ;
79730   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
79731   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
79732
79733   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
79734   {
79735     try {
79736       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
79737     } catch (std::out_of_range& e) {
79738       {
79739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79740       };
79741     } catch (std::exception& e) {
79742       {
79743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79744       };
79745     } catch (...) {
79746       {
79747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79748       };
79749     }
79750   }
79751   jresult = (void *)result;
79752   return jresult;
79753 }
79754
79755
79756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
79757   void * jresult ;
79758   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
79759
79760   {
79761     try {
79762       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
79763     } catch (std::out_of_range& e) {
79764       {
79765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79766       };
79767     } catch (std::exception& e) {
79768       {
79769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79770       };
79771     } catch (...) {
79772       {
79773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79774       };
79775     }
79776   }
79777   jresult = (void *)result;
79778   return jresult;
79779 }
79780
79781
79782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
79783   void * jresult ;
79784   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
79785   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
79786
79787   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
79788   if (!arg1) {
79789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
79790     return 0;
79791   }
79792   {
79793     try {
79794       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
79795     } catch (std::out_of_range& e) {
79796       {
79797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79798       };
79799     } catch (std::exception& e) {
79800       {
79801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79802       };
79803     } catch (...) {
79804       {
79805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79806       };
79807     }
79808   }
79809   jresult = (void *)result;
79810   return jresult;
79811 }
79812
79813
79814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
79815   void * jresult ;
79816   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
79817   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
79818   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
79819
79820   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
79821   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
79822   if (!arg2) {
79823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
79824     return 0;
79825   }
79826   {
79827     try {
79828       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
79829     } catch (std::out_of_range& e) {
79830       {
79831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79832       };
79833     } catch (std::exception& e) {
79834       {
79835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79836       };
79837     } catch (...) {
79838       {
79839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79840       };
79841     }
79842   }
79843   jresult = (void *)result;
79844   return jresult;
79845 }
79846
79847
79848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
79849   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
79850
79851   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
79852   {
79853     try {
79854       delete arg1;
79855     } catch (std::out_of_range& e) {
79856       {
79857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79858       };
79859     } catch (std::exception& e) {
79860       {
79861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79862       };
79863     } catch (...) {
79864       {
79865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79866       };
79867     }
79868   }
79869 }
79870
79871
79872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
79873   void * jresult ;
79874   Dali::Toolkit::PageFactory *arg1 = 0 ;
79875   Dali::Vector2 *arg2 = 0 ;
79876   Dali::Toolkit::PageTurnLandscapeView result;
79877
79878   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79879   if (!arg1) {
79880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
79881     return 0;
79882   }
79883   arg2 = (Dali::Vector2 *)jarg2;
79884   if (!arg2) {
79885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79886     return 0;
79887   }
79888   {
79889     try {
79890       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
79891     } catch (std::out_of_range& e) {
79892       {
79893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79894       };
79895     } catch (std::exception& e) {
79896       {
79897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79898       };
79899     } catch (...) {
79900       {
79901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79902       };
79903     }
79904   }
79905   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
79906   return jresult;
79907 }
79908
79909
79910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
79911   void * jresult ;
79912   Dali::BaseHandle arg1 ;
79913   Dali::BaseHandle *argp1 ;
79914   Dali::Toolkit::PageTurnLandscapeView result;
79915
79916   argp1 = (Dali::BaseHandle *)jarg1;
79917   if (!argp1) {
79918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79919     return 0;
79920   }
79921   arg1 = *argp1;
79922   {
79923     try {
79924       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
79925     } catch (std::out_of_range& e) {
79926       {
79927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79928       };
79929     } catch (std::exception& e) {
79930       {
79931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79932       };
79933     } catch (...) {
79934       {
79935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79936       };
79937     }
79938   }
79939   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
79940   return jresult;
79941 }
79942
79943
79944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
79945   void * jresult ;
79946   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
79947
79948   {
79949     try {
79950       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
79951     } catch (std::out_of_range& e) {
79952       {
79953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79954       };
79955     } catch (std::exception& e) {
79956       {
79957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79958       };
79959     } catch (...) {
79960       {
79961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79962       };
79963     }
79964   }
79965   jresult = (void *)result;
79966   return jresult;
79967 }
79968
79969
79970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
79971   void * jresult ;
79972   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
79973   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
79974
79975   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
79976   if (!arg1) {
79977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
79978     return 0;
79979   }
79980   {
79981     try {
79982       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
79983     } catch (std::out_of_range& e) {
79984       {
79985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79986       };
79987     } catch (std::exception& e) {
79988       {
79989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79990       };
79991     } catch (...) {
79992       {
79993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79994       };
79995     }
79996   }
79997   jresult = (void *)result;
79998   return jresult;
79999 }
80000
80001
80002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
80003   void * jresult ;
80004   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
80005   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
80006   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80007
80008   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80009   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
80010   if (!arg2) {
80011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
80012     return 0;
80013   }
80014   {
80015     try {
80016       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
80017     } catch (std::out_of_range& e) {
80018       {
80019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80020       };
80021     } catch (std::exception& e) {
80022       {
80023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80024       };
80025     } catch (...) {
80026       {
80027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80028       };
80029     }
80030   }
80031   jresult = (void *)result;
80032   return jresult;
80033 }
80034
80035
80036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
80037   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
80038
80039   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80040   {
80041     try {
80042       delete arg1;
80043     } catch (std::out_of_range& e) {
80044       {
80045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80046       };
80047     } catch (std::exception& e) {
80048       {
80049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80050       };
80051     } catch (...) {
80052       {
80053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80054       };
80055     }
80056   }
80057 }
80058
80059
80060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
80061   void * jresult ;
80062   Dali::Toolkit::PageFactory *arg1 = 0 ;
80063   Dali::Vector2 *arg2 = 0 ;
80064   Dali::Toolkit::PageTurnPortraitView result;
80065
80066   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
80067   if (!arg1) {
80068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
80069     return 0;
80070   }
80071   arg2 = (Dali::Vector2 *)jarg2;
80072   if (!arg2) {
80073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80074     return 0;
80075   }
80076   {
80077     try {
80078       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
80079     } catch (std::out_of_range& e) {
80080       {
80081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80082       };
80083     } catch (std::exception& e) {
80084       {
80085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80086       };
80087     } catch (...) {
80088       {
80089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80090       };
80091     }
80092   }
80093   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
80094   return jresult;
80095 }
80096
80097
80098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
80099   void * jresult ;
80100   Dali::BaseHandle arg1 ;
80101   Dali::BaseHandle *argp1 ;
80102   Dali::Toolkit::PageTurnPortraitView result;
80103
80104   argp1 = (Dali::BaseHandle *)jarg1;
80105   if (!argp1) {
80106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80107     return 0;
80108   }
80109   arg1 = *argp1;
80110   {
80111     try {
80112       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
80113     } catch (std::out_of_range& e) {
80114       {
80115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80116       };
80117     } catch (std::exception& e) {
80118       {
80119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80120       };
80121     } catch (...) {
80122       {
80123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80124       };
80125     }
80126   }
80127   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
80128   return jresult;
80129 }
80130
80131
80132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
80133   void * jresult ;
80134   Dali::Toolkit::Visual::Base *result = 0 ;
80135
80136   {
80137     try {
80138       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
80139     } catch (std::out_of_range& e) {
80140       {
80141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80142       };
80143     } catch (std::exception& e) {
80144       {
80145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80146       };
80147     } catch (...) {
80148       {
80149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80150       };
80151     }
80152   }
80153   jresult = (void *)result;
80154   return jresult;
80155 }
80156
80157
80158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
80159   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80160
80161   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80162   {
80163     try {
80164       delete arg1;
80165     } catch (std::out_of_range& e) {
80166       {
80167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80168       };
80169     } catch (std::exception& e) {
80170       {
80171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80172       };
80173     } catch (...) {
80174       {
80175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80176       };
80177     }
80178   }
80179 }
80180
80181
80182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
80183   void * jresult ;
80184   Dali::Toolkit::Visual::Base *arg1 = 0 ;
80185   Dali::Toolkit::Visual::Base *result = 0 ;
80186
80187   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80188   if (!arg1) {
80189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
80190     return 0;
80191   }
80192   {
80193     try {
80194       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
80195     } catch (std::out_of_range& e) {
80196       {
80197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80198       };
80199     } catch (std::exception& e) {
80200       {
80201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80202       };
80203     } catch (...) {
80204       {
80205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80206       };
80207     }
80208   }
80209   jresult = (void *)result;
80210   return jresult;
80211 }
80212
80213
80214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
80215   void * jresult ;
80216   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80217   Dali::Toolkit::Visual::Base *arg2 = 0 ;
80218   Dali::Toolkit::Visual::Base *result = 0 ;
80219
80220   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80221   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
80222   if (!arg2) {
80223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
80224     return 0;
80225   }
80226   {
80227     try {
80228       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
80229     } catch (std::out_of_range& e) {
80230       {
80231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80232       };
80233     } catch (std::exception& e) {
80234       {
80235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80236       };
80237     } catch (...) {
80238       {
80239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80240       };
80241     }
80242   }
80243   jresult = (void *)result;
80244   return jresult;
80245 }
80246
80247
80248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetSize(void * jarg1, void * jarg2) {
80249   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80250   Dali::Vector2 *arg2 = 0 ;
80251
80252   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80253   arg2 = (Dali::Vector2 *)jarg2;
80254   if (!arg2) {
80255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80256     return ;
80257   }
80258   {
80259     try {
80260       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
80261     } catch (std::out_of_range& e) {
80262       {
80263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80264       };
80265     } catch (std::exception& e) {
80266       {
80267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80268       };
80269     } catch (...) {
80270       {
80271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80272       };
80273     }
80274   }
80275 }
80276
80277
80278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_GetSize(void * jarg1) {
80279   void * jresult ;
80280   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80281   Dali::Vector2 *result = 0 ;
80282
80283   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80284   {
80285     try {
80286       result = (Dali::Vector2 *) &((Dali::Toolkit::Visual::Base const *)arg1)->GetSize();
80287     } catch (std::out_of_range& e) {
80288       {
80289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80290       };
80291     } catch (std::exception& e) {
80292       {
80293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80294       };
80295     } catch (...) {
80296       {
80297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80298       };
80299     }
80300   }
80301   jresult = (void *)result;
80302   return jresult;
80303 }
80304
80305
80306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
80307   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80308   Dali::Vector2 *arg2 = 0 ;
80309
80310   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80311   arg2 = (Dali::Vector2 *)jarg2;
80312   if (!arg2) {
80313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
80314     return ;
80315   }
80316   {
80317     try {
80318       ((Dali::Toolkit::Visual::Base const *)arg1)->GetNaturalSize(*arg2);
80319     } catch (std::out_of_range& e) {
80320       {
80321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80322       };
80323     } catch (std::exception& e) {
80324       {
80325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80326       };
80327     } catch (...) {
80328       {
80329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80330       };
80331     }
80332   }
80333 }
80334
80335
80336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
80337   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80338   float arg2 ;
80339
80340   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80341   arg2 = (float)jarg2;
80342   {
80343     try {
80344       (arg1)->SetDepthIndex(arg2);
80345     } catch (std::out_of_range& e) {
80346       {
80347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80348       };
80349     } catch (std::exception& e) {
80350       {
80351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80352       };
80353     } catch (...) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80356       };
80357     }
80358   }
80359 }
80360
80361
80362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
80363   float jresult ;
80364   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80365   float result;
80366
80367   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80368   {
80369     try {
80370       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
80371     } catch (std::out_of_range& e) {
80372       {
80373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80374       };
80375     } catch (std::exception& e) {
80376       {
80377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80378       };
80379     } catch (...) {
80380       {
80381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80382       };
80383     }
80384   }
80385   jresult = result;
80386   return jresult;
80387 }
80388
80389
80390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetOnStage(void * jarg1, void * jarg2) {
80391   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80392   Dali::Actor *arg2 = 0 ;
80393
80394   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80395   arg2 = (Dali::Actor *)jarg2;
80396   if (!arg2) {
80397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80398     return ;
80399   }
80400   {
80401     try {
80402       (arg1)->SetOnStage(*arg2);
80403     } catch (std::out_of_range& e) {
80404       {
80405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80406       };
80407     } catch (std::exception& e) {
80408       {
80409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80410       };
80411     } catch (...) {
80412       {
80413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80414       };
80415     }
80416   }
80417 }
80418
80419
80420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetOffStage(void * jarg1, void * jarg2) {
80421   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80422   Dali::Actor *arg2 = 0 ;
80423
80424   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80425   arg2 = (Dali::Actor *)jarg2;
80426   if (!arg2) {
80427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80428     return ;
80429   }
80430   {
80431     try {
80432       (arg1)->SetOffStage(*arg2);
80433     } catch (std::out_of_range& e) {
80434       {
80435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80436       };
80437     } catch (std::exception& e) {
80438       {
80439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80440       };
80441     } catch (...) {
80442       {
80443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80444       };
80445     }
80446   }
80447 }
80448
80449
80450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_RemoveAndReset(void * jarg1, void * jarg2) {
80451   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80452   Dali::Actor *arg2 = 0 ;
80453
80454   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80455   arg2 = (Dali::Actor *)jarg2;
80456   if (!arg2) {
80457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80458     return ;
80459   }
80460   {
80461     try {
80462       (arg1)->RemoveAndReset(*arg2);
80463     } catch (std::out_of_range& e) {
80464       {
80465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80466       };
80467     } catch (std::exception& e) {
80468       {
80469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80470       };
80471     } catch (...) {
80472       {
80473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80474       };
80475     }
80476   }
80477 }
80478
80479
80480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
80481   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80482   Dali::Property::Map *arg2 = 0 ;
80483
80484   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80485   arg2 = (Dali::Property::Map *)jarg2;
80486   if (!arg2) {
80487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
80488     return ;
80489   }
80490   {
80491     try {
80492       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
80493     } catch (std::out_of_range& e) {
80494       {
80495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80496       };
80497     } catch (std::exception& e) {
80498       {
80499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80500       };
80501     } catch (...) {
80502       {
80503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80504       };
80505     }
80506   }
80507 }
80508
80509
80510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
80511   void * jresult ;
80512   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
80513   Dali::Toolkit::Visual::Base *result = 0 ;
80514
80515   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
80516   {
80517     try {
80518       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
80519     } catch (std::out_of_range& e) {
80520       {
80521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80522       };
80523     } catch (std::exception& e) {
80524       {
80525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80526       };
80527     } catch (...) {
80528       {
80529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80530       };
80531     }
80532   }
80533   jresult = (void *)result;
80534   return jresult;
80535 }
80536
80537
80538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
80539   void * jresult ;
80540   Dali::Toolkit::VisualFactory result;
80541
80542   {
80543     try {
80544       result = Dali::Toolkit::VisualFactory::Get();
80545     } catch (std::out_of_range& e) {
80546       {
80547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80548       };
80549     } catch (std::exception& e) {
80550       {
80551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80552       };
80553     } catch (...) {
80554       {
80555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80556       };
80557     }
80558   }
80559   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
80560   return jresult;
80561 }
80562
80563
80564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
80565   void * jresult ;
80566   Dali::Toolkit::VisualFactory *result = 0 ;
80567
80568   {
80569     try {
80570       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
80571     } catch (std::out_of_range& e) {
80572       {
80573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80574       };
80575     } catch (std::exception& e) {
80576       {
80577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80578       };
80579     } catch (...) {
80580       {
80581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80582       };
80583     }
80584   }
80585   jresult = (void *)result;
80586   return jresult;
80587 }
80588
80589
80590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
80591   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
80592
80593   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
80594   {
80595     try {
80596       delete arg1;
80597     } catch (std::out_of_range& e) {
80598       {
80599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80600       };
80601     } catch (std::exception& e) {
80602       {
80603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80604       };
80605     } catch (...) {
80606       {
80607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80608       };
80609     }
80610   }
80611 }
80612
80613
80614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
80615   void * jresult ;
80616   Dali::Toolkit::VisualFactory *arg1 = 0 ;
80617   Dali::Toolkit::VisualFactory *result = 0 ;
80618
80619   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
80620   if (!arg1) {
80621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
80622     return 0;
80623   }
80624   {
80625     try {
80626       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
80627     } catch (std::out_of_range& e) {
80628       {
80629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80630       };
80631     } catch (std::exception& e) {
80632       {
80633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80634       };
80635     } catch (...) {
80636       {
80637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80638       };
80639     }
80640   }
80641   jresult = (void *)result;
80642   return jresult;
80643 }
80644
80645
80646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
80647   void * jresult ;
80648   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
80649   Dali::Toolkit::VisualFactory *arg2 = 0 ;
80650   Dali::Toolkit::VisualFactory *result = 0 ;
80651
80652   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
80653   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
80654   if (!arg2) {
80655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
80656     return 0;
80657   }
80658   {
80659     try {
80660       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
80661     } catch (std::out_of_range& e) {
80662       {
80663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80664       };
80665     } catch (std::exception& e) {
80666       {
80667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80668       };
80669     } catch (...) {
80670       {
80671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80672       };
80673     }
80674   }
80675   jresult = (void *)result;
80676   return jresult;
80677 }
80678
80679
80680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
80681   void * jresult ;
80682   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
80683   Dali::Property::Map *arg2 = 0 ;
80684   Dali::Toolkit::Visual::Base result;
80685
80686   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
80687   arg2 = (Dali::Property::Map *)jarg2;
80688   if (!arg2) {
80689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
80690     return 0;
80691   }
80692   {
80693     try {
80694       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
80695     } catch (std::out_of_range& e) {
80696       {
80697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80698       };
80699     } catch (std::exception& e) {
80700       {
80701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80702       };
80703     } catch (...) {
80704       {
80705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80706       };
80707     }
80708   }
80709   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
80710   return jresult;
80711 }
80712
80713
80714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
80715   void * jresult ;
80716   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
80717   Dali::Image *arg2 = 0 ;
80718   Dali::Toolkit::Visual::Base result;
80719
80720   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
80721   arg2 = (Dali::Image *)jarg2;
80722   if (!arg2) {
80723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
80724     return 0;
80725   }
80726   {
80727     try {
80728       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
80729     } catch (std::out_of_range& e) {
80730       {
80731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80732       };
80733     } catch (std::exception& e) {
80734       {
80735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80736       };
80737     } catch (...) {
80738       {
80739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80740       };
80741     }
80742   }
80743   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
80744   return jresult;
80745 }
80746
80747
80748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
80749   void * jresult ;
80750   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
80751   std::string *arg2 = 0 ;
80752   Dali::ImageDimensions arg3 ;
80753   Dali::ImageDimensions *argp3 ;
80754   Dali::Toolkit::Visual::Base result;
80755
80756   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
80757   if (!jarg2) {
80758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80759     return 0;
80760   }
80761   std::string arg2_str(jarg2);
80762   arg2 = &arg2_str;
80763   argp3 = (Dali::ImageDimensions *)jarg3;
80764   if (!argp3) {
80765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
80766     return 0;
80767   }
80768   arg3 = *argp3;
80769   {
80770     try {
80771       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
80772     } catch (std::out_of_range& e) {
80773       {
80774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80775       };
80776     } catch (std::exception& e) {
80777       {
80778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80779       };
80780     } catch (...) {
80781       {
80782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80783       };
80784     }
80785   }
80786   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
80787
80788   //argout typemap for const std::string&
80789
80790   return jresult;
80791 }
80792
80793
80794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
80795   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80796
80797   arg1 = (std::vector< unsigned int > *)jarg1;
80798   {
80799     try {
80800       (arg1)->clear();
80801     } catch (std::out_of_range& e) {
80802       {
80803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80804       };
80805     } catch (std::exception& e) {
80806       {
80807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80808       };
80809     } catch (...) {
80810       {
80811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80812       };
80813     }
80814   }
80815 }
80816
80817
80818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
80819   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80820   unsigned int *arg2 = 0 ;
80821   unsigned int temp2 ;
80822
80823   arg1 = (std::vector< unsigned int > *)jarg1;
80824   temp2 = (unsigned int)jarg2;
80825   arg2 = &temp2;
80826   {
80827     try {
80828       (arg1)->push_back((unsigned int const &)*arg2);
80829     } catch (std::out_of_range& e) {
80830       {
80831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80832       };
80833     } catch (std::exception& e) {
80834       {
80835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80836       };
80837     } catch (...) {
80838       {
80839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80840       };
80841     }
80842   }
80843 }
80844
80845
80846 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
80847   unsigned long jresult ;
80848   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80849   std::vector< unsigned int >::size_type result;
80850
80851   arg1 = (std::vector< unsigned int > *)jarg1;
80852   {
80853     try {
80854       result = ((std::vector< unsigned int > const *)arg1)->size();
80855     } catch (std::out_of_range& e) {
80856       {
80857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80858       };
80859     } catch (std::exception& e) {
80860       {
80861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80862       };
80863     } catch (...) {
80864       {
80865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80866       };
80867     }
80868   }
80869   jresult = (unsigned long)result;
80870   return jresult;
80871 }
80872
80873
80874 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
80875   unsigned long jresult ;
80876   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80877   std::vector< unsigned int >::size_type result;
80878
80879   arg1 = (std::vector< unsigned int > *)jarg1;
80880   {
80881     try {
80882       result = ((std::vector< unsigned int > const *)arg1)->capacity();
80883     } catch (std::out_of_range& e) {
80884       {
80885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80886       };
80887     } catch (std::exception& e) {
80888       {
80889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80890       };
80891     } catch (...) {
80892       {
80893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80894       };
80895     }
80896   }
80897   jresult = (unsigned long)result;
80898   return jresult;
80899 }
80900
80901
80902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
80903   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80904   std::vector< unsigned int >::size_type arg2 ;
80905
80906   arg1 = (std::vector< unsigned int > *)jarg1;
80907   arg2 = (std::vector< unsigned int >::size_type)jarg2;
80908   {
80909     try {
80910       (arg1)->reserve(arg2);
80911     } catch (std::out_of_range& e) {
80912       {
80913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80914       };
80915     } catch (std::exception& e) {
80916       {
80917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80918       };
80919     } catch (...) {
80920       {
80921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80922       };
80923     }
80924   }
80925 }
80926
80927
80928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
80929   void * jresult ;
80930   std::vector< unsigned int > *result = 0 ;
80931
80932   {
80933     try {
80934       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
80935     } catch (std::out_of_range& e) {
80936       {
80937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80938       };
80939     } catch (std::exception& e) {
80940       {
80941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80942       };
80943     } catch (...) {
80944       {
80945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80946       };
80947     }
80948   }
80949   jresult = (void *)result;
80950   return jresult;
80951 }
80952
80953
80954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
80955   void * jresult ;
80956   std::vector< unsigned int > *arg1 = 0 ;
80957   std::vector< unsigned int > *result = 0 ;
80958
80959   arg1 = (std::vector< unsigned int > *)jarg1;
80960   if (!arg1) {
80961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80962     return 0;
80963   }
80964   {
80965     try {
80966       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
80967     } catch (std::out_of_range& e) {
80968       {
80969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80970       };
80971     } catch (std::exception& e) {
80972       {
80973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80974       };
80975     } catch (...) {
80976       {
80977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80978       };
80979     }
80980   }
80981   jresult = (void *)result;
80982   return jresult;
80983 }
80984
80985
80986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
80987   void * jresult ;
80988   int arg1 ;
80989   std::vector< unsigned int > *result = 0 ;
80990
80991   arg1 = (int)jarg1;
80992   {
80993     try {
80994       try {
80995         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
80996       }
80997       catch(std::out_of_range &_e) {
80998         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80999         return 0;
81000       }
81001
81002     } catch (std::out_of_range& e) {
81003       {
81004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81005       };
81006     } catch (std::exception& e) {
81007       {
81008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81009       };
81010     } catch (...) {
81011       {
81012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81013       };
81014     }
81015   }
81016   jresult = (void *)result;
81017   return jresult;
81018 }
81019
81020
81021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
81022   unsigned int jresult ;
81023   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81024   int arg2 ;
81025   unsigned int result;
81026
81027   arg1 = (std::vector< unsigned int > *)jarg1;
81028   arg2 = (int)jarg2;
81029   {
81030     try {
81031       try {
81032         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
81033       }
81034       catch(std::out_of_range &_e) {
81035         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81036         return 0;
81037       }
81038
81039     } catch (std::out_of_range& e) {
81040       {
81041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81042       };
81043     } catch (std::exception& e) {
81044       {
81045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81046       };
81047     } catch (...) {
81048       {
81049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81050       };
81051     }
81052   }
81053   jresult = result;
81054   return jresult;
81055 }
81056
81057
81058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
81059   unsigned int jresult ;
81060   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81061   int arg2 ;
81062   unsigned int *result = 0 ;
81063
81064   arg1 = (std::vector< unsigned int > *)jarg1;
81065   arg2 = (int)jarg2;
81066   {
81067     try {
81068       try {
81069         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
81070       }
81071       catch(std::out_of_range &_e) {
81072         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81073         return 0;
81074       }
81075
81076     } catch (std::out_of_range& e) {
81077       {
81078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81079       };
81080     } catch (std::exception& e) {
81081       {
81082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81083       };
81084     } catch (...) {
81085       {
81086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81087       };
81088     }
81089   }
81090   jresult = *result;
81091   return jresult;
81092 }
81093
81094
81095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
81096   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81097   int arg2 ;
81098   unsigned int *arg3 = 0 ;
81099   unsigned int temp3 ;
81100
81101   arg1 = (std::vector< unsigned int > *)jarg1;
81102   arg2 = (int)jarg2;
81103   temp3 = (unsigned int)jarg3;
81104   arg3 = &temp3;
81105   {
81106     try {
81107       try {
81108         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
81109       }
81110       catch(std::out_of_range &_e) {
81111         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81112         return ;
81113       }
81114
81115     } catch (std::out_of_range& e) {
81116       {
81117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81118       };
81119     } catch (std::exception& e) {
81120       {
81121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81122       };
81123     } catch (...) {
81124       {
81125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81126       };
81127     }
81128   }
81129 }
81130
81131
81132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
81133   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81134   std::vector< unsigned int > *arg2 = 0 ;
81135
81136   arg1 = (std::vector< unsigned int > *)jarg1;
81137   arg2 = (std::vector< unsigned int > *)jarg2;
81138   if (!arg2) {
81139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
81140     return ;
81141   }
81142   {
81143     try {
81144       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
81145     } catch (std::out_of_range& e) {
81146       {
81147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81148       };
81149     } catch (std::exception& e) {
81150       {
81151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81152       };
81153     } catch (...) {
81154       {
81155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81156       };
81157     }
81158   }
81159 }
81160
81161
81162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
81163   void * jresult ;
81164   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81165   int arg2 ;
81166   int arg3 ;
81167   std::vector< unsigned int > *result = 0 ;
81168
81169   arg1 = (std::vector< unsigned int > *)jarg1;
81170   arg2 = (int)jarg2;
81171   arg3 = (int)jarg3;
81172   {
81173     try {
81174       try {
81175         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
81176       }
81177       catch(std::out_of_range &_e) {
81178         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81179         return 0;
81180       }
81181       catch(std::invalid_argument &_e) {
81182         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81183         return 0;
81184       }
81185
81186     } catch (std::out_of_range& e) {
81187       {
81188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81189       };
81190     } catch (std::exception& e) {
81191       {
81192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81193       };
81194     } catch (...) {
81195       {
81196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81197       };
81198     }
81199   }
81200   jresult = (void *)result;
81201   return jresult;
81202 }
81203
81204
81205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
81206   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81207   int arg2 ;
81208   unsigned int *arg3 = 0 ;
81209   unsigned int temp3 ;
81210
81211   arg1 = (std::vector< unsigned int > *)jarg1;
81212   arg2 = (int)jarg2;
81213   temp3 = (unsigned int)jarg3;
81214   arg3 = &temp3;
81215   {
81216     try {
81217       try {
81218         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
81219       }
81220       catch(std::out_of_range &_e) {
81221         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81222         return ;
81223       }
81224
81225     } catch (std::out_of_range& e) {
81226       {
81227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81228       };
81229     } catch (std::exception& e) {
81230       {
81231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81232       };
81233     } catch (...) {
81234       {
81235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81236       };
81237     }
81238   }
81239 }
81240
81241
81242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
81243   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81244   int arg2 ;
81245   std::vector< unsigned int > *arg3 = 0 ;
81246
81247   arg1 = (std::vector< unsigned int > *)jarg1;
81248   arg2 = (int)jarg2;
81249   arg3 = (std::vector< unsigned int > *)jarg3;
81250   if (!arg3) {
81251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
81252     return ;
81253   }
81254   {
81255     try {
81256       try {
81257         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
81258       }
81259       catch(std::out_of_range &_e) {
81260         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81261         return ;
81262       }
81263
81264     } catch (std::out_of_range& e) {
81265       {
81266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81267       };
81268     } catch (std::exception& e) {
81269       {
81270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81271       };
81272     } catch (...) {
81273       {
81274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81275       };
81276     }
81277   }
81278 }
81279
81280
81281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
81282   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81283   int arg2 ;
81284
81285   arg1 = (std::vector< unsigned int > *)jarg1;
81286   arg2 = (int)jarg2;
81287   {
81288     try {
81289       try {
81290         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
81291       }
81292       catch(std::out_of_range &_e) {
81293         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81294         return ;
81295       }
81296
81297     } catch (std::out_of_range& e) {
81298       {
81299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81300       };
81301     } catch (std::exception& e) {
81302       {
81303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81304       };
81305     } catch (...) {
81306       {
81307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81308       };
81309     }
81310   }
81311 }
81312
81313
81314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
81315   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81316   int arg2 ;
81317   int arg3 ;
81318
81319   arg1 = (std::vector< unsigned int > *)jarg1;
81320   arg2 = (int)jarg2;
81321   arg3 = (int)jarg3;
81322   {
81323     try {
81324       try {
81325         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
81326       }
81327       catch(std::out_of_range &_e) {
81328         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81329         return ;
81330       }
81331       catch(std::invalid_argument &_e) {
81332         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81333         return ;
81334       }
81335
81336     } catch (std::out_of_range& e) {
81337       {
81338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81339       };
81340     } catch (std::exception& e) {
81341       {
81342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81343       };
81344     } catch (...) {
81345       {
81346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81347       };
81348     }
81349   }
81350 }
81351
81352
81353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
81354   void * jresult ;
81355   unsigned int *arg1 = 0 ;
81356   int arg2 ;
81357   unsigned int temp1 ;
81358   std::vector< unsigned int > *result = 0 ;
81359
81360   temp1 = (unsigned int)jarg1;
81361   arg1 = &temp1;
81362   arg2 = (int)jarg2;
81363   {
81364     try {
81365       try {
81366         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
81367       }
81368       catch(std::out_of_range &_e) {
81369         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81370         return 0;
81371       }
81372
81373     } catch (std::out_of_range& e) {
81374       {
81375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81376       };
81377     } catch (std::exception& e) {
81378       {
81379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (...) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81384       };
81385     }
81386   }
81387   jresult = (void *)result;
81388   return jresult;
81389 }
81390
81391
81392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
81393   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81394
81395   arg1 = (std::vector< unsigned int > *)jarg1;
81396   {
81397     try {
81398       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
81399     } catch (std::out_of_range& e) {
81400       {
81401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81402       };
81403     } catch (std::exception& e) {
81404       {
81405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81406       };
81407     } catch (...) {
81408       {
81409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81410       };
81411     }
81412   }
81413 }
81414
81415
81416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
81417   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81418   int arg2 ;
81419   int arg3 ;
81420
81421   arg1 = (std::vector< unsigned int > *)jarg1;
81422   arg2 = (int)jarg2;
81423   arg3 = (int)jarg3;
81424   {
81425     try {
81426       try {
81427         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
81428       }
81429       catch(std::out_of_range &_e) {
81430         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81431         return ;
81432       }
81433       catch(std::invalid_argument &_e) {
81434         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81435         return ;
81436       }
81437
81438     } catch (std::out_of_range& e) {
81439       {
81440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81441       };
81442     } catch (std::exception& e) {
81443       {
81444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81445       };
81446     } catch (...) {
81447       {
81448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81449       };
81450     }
81451   }
81452 }
81453
81454
81455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
81456   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81457   int arg2 ;
81458   std::vector< unsigned int > *arg3 = 0 ;
81459
81460   arg1 = (std::vector< unsigned int > *)jarg1;
81461   arg2 = (int)jarg2;
81462   arg3 = (std::vector< unsigned int > *)jarg3;
81463   if (!arg3) {
81464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
81465     return ;
81466   }
81467   {
81468     try {
81469       try {
81470         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
81471       }
81472       catch(std::out_of_range &_e) {
81473         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81474         return ;
81475       }
81476
81477     } catch (std::out_of_range& e) {
81478       {
81479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81480       };
81481     } catch (std::exception& e) {
81482       {
81483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81484       };
81485     } catch (...) {
81486       {
81487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81488       };
81489     }
81490   }
81491 }
81492
81493
81494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
81495   unsigned int jresult ;
81496   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81497   unsigned int *arg2 = 0 ;
81498   unsigned int temp2 ;
81499   bool result;
81500
81501   arg1 = (std::vector< unsigned int > *)jarg1;
81502   temp2 = (unsigned int)jarg2;
81503   arg2 = &temp2;
81504   {
81505     try {
81506       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
81507     } catch (std::out_of_range& e) {
81508       {
81509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81510       };
81511     } catch (std::exception& e) {
81512       {
81513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81514       };
81515     } catch (...) {
81516       {
81517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81518       };
81519     }
81520   }
81521   jresult = result;
81522   return jresult;
81523 }
81524
81525
81526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
81527   int jresult ;
81528   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81529   unsigned int *arg2 = 0 ;
81530   unsigned int temp2 ;
81531   int result;
81532
81533   arg1 = (std::vector< unsigned int > *)jarg1;
81534   temp2 = (unsigned int)jarg2;
81535   arg2 = &temp2;
81536   {
81537     try {
81538       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
81539     } catch (std::out_of_range& e) {
81540       {
81541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81542       };
81543     } catch (std::exception& e) {
81544       {
81545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81546       };
81547     } catch (...) {
81548       {
81549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81550       };
81551     }
81552   }
81553   jresult = result;
81554   return jresult;
81555 }
81556
81557
81558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
81559   int jresult ;
81560   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81561   unsigned int *arg2 = 0 ;
81562   unsigned int temp2 ;
81563   int result;
81564
81565   arg1 = (std::vector< unsigned int > *)jarg1;
81566   temp2 = (unsigned int)jarg2;
81567   arg2 = &temp2;
81568   {
81569     try {
81570       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
81571     } catch (std::out_of_range& e) {
81572       {
81573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81574       };
81575     } catch (std::exception& e) {
81576       {
81577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81578       };
81579     } catch (...) {
81580       {
81581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81582       };
81583     }
81584   }
81585   jresult = result;
81586   return jresult;
81587 }
81588
81589
81590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
81591   unsigned int jresult ;
81592   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81593   unsigned int *arg2 = 0 ;
81594   unsigned int temp2 ;
81595   bool result;
81596
81597   arg1 = (std::vector< unsigned int > *)jarg1;
81598   temp2 = (unsigned int)jarg2;
81599   arg2 = &temp2;
81600   {
81601     try {
81602       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
81603     } catch (std::out_of_range& e) {
81604       {
81605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81606       };
81607     } catch (std::exception& e) {
81608       {
81609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81610       };
81611     } catch (...) {
81612       {
81613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81614       };
81615     }
81616   }
81617   jresult = result;
81618   return jresult;
81619 }
81620
81621
81622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
81623   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81624
81625   arg1 = (std::vector< unsigned int > *)jarg1;
81626   {
81627     try {
81628       delete arg1;
81629     } catch (std::out_of_range& e) {
81630       {
81631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81632       };
81633     } catch (std::exception& e) {
81634       {
81635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81636       };
81637     } catch (...) {
81638       {
81639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81640       };
81641     }
81642   }
81643 }
81644
81645
81646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
81647   void * jresult ;
81648   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81649
81650   {
81651     try {
81652       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
81653     } catch (std::out_of_range& e) {
81654       {
81655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81656       };
81657     } catch (std::exception& e) {
81658       {
81659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81660       };
81661     } catch (...) {
81662       {
81663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81664       };
81665     }
81666   }
81667   jresult = (void *)result;
81668   return jresult;
81669 }
81670
81671
81672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
81673   void * jresult ;
81674   unsigned int arg1 ;
81675   Dali::Actor arg2 ;
81676   Dali::Actor *argp2 ;
81677   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81678
81679   arg1 = (unsigned int)jarg1;
81680   argp2 = (Dali::Actor *)jarg2;
81681   if (!argp2) {
81682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81683     return 0;
81684   }
81685   arg2 = *argp2;
81686   {
81687     try {
81688       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
81689     } catch (std::out_of_range& e) {
81690       {
81691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81692       };
81693     } catch (std::exception& e) {
81694       {
81695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81696       };
81697     } catch (...) {
81698       {
81699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81700       };
81701     }
81702   }
81703   jresult = (void *)result;
81704   return jresult;
81705 }
81706
81707
81708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
81709   void * jresult ;
81710   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81711   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81712
81713   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81714   if (!arg1) {
81715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81716     return 0;
81717   }
81718   {
81719     try {
81720       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
81721     } catch (std::out_of_range& e) {
81722       {
81723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81724       };
81725     } catch (std::exception& e) {
81726       {
81727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81728       };
81729     } catch (...) {
81730       {
81731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81732       };
81733     }
81734   }
81735   jresult = (void *)result;
81736   return jresult;
81737 }
81738
81739
81740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
81741   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81742   unsigned int arg2 ;
81743
81744   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81745   arg2 = (unsigned int)jarg2;
81746   if (arg1) (arg1)->first = arg2;
81747 }
81748
81749
81750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
81751   unsigned int jresult ;
81752   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81753   unsigned int result;
81754
81755   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81756   result = (unsigned int) ((arg1)->first);
81757   jresult = result;
81758   return jresult;
81759 }
81760
81761
81762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
81763   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81764   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
81765
81766   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81767   arg2 = (Dali::Actor *)jarg2;
81768   if (arg1) (arg1)->second = *arg2;
81769 }
81770
81771
81772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
81773   void * jresult ;
81774   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81775   Dali::Actor *result = 0 ;
81776
81777   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81778   result = (Dali::Actor *)& ((arg1)->second);
81779   jresult = (void *)result;
81780   return jresult;
81781 }
81782
81783
81784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
81785   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81786
81787   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81788   {
81789     try {
81790       delete arg1;
81791     } catch (std::out_of_range& e) {
81792       {
81793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81794       };
81795     } catch (std::exception& e) {
81796       {
81797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81798       };
81799     } catch (...) {
81800       {
81801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81802       };
81803     }
81804   }
81805 }
81806
81807
81808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
81809   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81810
81811   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81812   {
81813     try {
81814       (arg1)->clear();
81815     } catch (std::out_of_range& e) {
81816       {
81817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81818       };
81819     } catch (std::exception& e) {
81820       {
81821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81822       };
81823     } catch (...) {
81824       {
81825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81826       };
81827     }
81828   }
81829 }
81830
81831
81832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
81833   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81834   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
81835
81836   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81837   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
81838   if (!arg2) {
81839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81840     return ;
81841   }
81842   {
81843     try {
81844       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
81845     } catch (std::out_of_range& e) {
81846       {
81847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81848       };
81849     } catch (std::exception& e) {
81850       {
81851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81852       };
81853     } catch (...) {
81854       {
81855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81856       };
81857     }
81858   }
81859 }
81860
81861
81862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
81863   unsigned long jresult ;
81864   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81865   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81866
81867   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81868   {
81869     try {
81870       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
81871     } catch (std::out_of_range& e) {
81872       {
81873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81874       };
81875     } catch (std::exception& e) {
81876       {
81877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81878       };
81879     } catch (...) {
81880       {
81881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81882       };
81883     }
81884   }
81885   jresult = (unsigned long)result;
81886   return jresult;
81887 }
81888
81889
81890 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
81891   unsigned long jresult ;
81892   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81893   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81894
81895   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81896   {
81897     try {
81898       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
81899     } catch (std::out_of_range& e) {
81900       {
81901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81902       };
81903     } catch (std::exception& e) {
81904       {
81905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81906       };
81907     } catch (...) {
81908       {
81909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81910       };
81911     }
81912   }
81913   jresult = (unsigned long)result;
81914   return jresult;
81915 }
81916
81917
81918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
81919   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81920   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
81921
81922   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81923   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
81924   {
81925     try {
81926       (arg1)->reserve(arg2);
81927     } catch (std::out_of_range& e) {
81928       {
81929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81930       };
81931     } catch (std::exception& e) {
81932       {
81933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81934       };
81935     } catch (...) {
81936       {
81937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81938       };
81939     }
81940   }
81941 }
81942
81943
81944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
81945   void * jresult ;
81946   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81947
81948   {
81949     try {
81950       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
81951     } catch (std::out_of_range& e) {
81952       {
81953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81954       };
81955     } catch (std::exception& e) {
81956       {
81957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81958       };
81959     } catch (...) {
81960       {
81961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81962       };
81963     }
81964   }
81965   jresult = (void *)result;
81966   return jresult;
81967 }
81968
81969
81970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
81971   void * jresult ;
81972   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
81973   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81974
81975   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81976   if (!arg1) {
81977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81978     return 0;
81979   }
81980   {
81981     try {
81982       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >((std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg1);
81983     } catch (std::out_of_range& e) {
81984       {
81985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81986       };
81987     } catch (std::exception& e) {
81988       {
81989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81990       };
81991     } catch (...) {
81992       {
81993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81994       };
81995     }
81996   }
81997   jresult = (void *)result;
81998   return jresult;
81999 }
82000
82001
82002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
82003   void * jresult ;
82004   int arg1 ;
82005   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
82006
82007   arg1 = (int)jarg1;
82008   {
82009     try {
82010       try {
82011         result = (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(arg1);
82012       }
82013       catch(std::out_of_range &_e) {
82014         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82015         return 0;
82016       }
82017
82018     } catch (std::out_of_range& e) {
82019       {
82020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82021       };
82022     } catch (std::exception& e) {
82023       {
82024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82025       };
82026     } catch (...) {
82027       {
82028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82029       };
82030     }
82031   }
82032   jresult = (void *)result;
82033   return jresult;
82034 }
82035
82036
82037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
82038   void * jresult ;
82039   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82040   int arg2 ;
82041   std::pair< unsigned int,Dali::Actor > result;
82042
82043   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82044   arg2 = (int)jarg2;
82045   {
82046     try {
82047       try {
82048         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
82049       }
82050       catch(std::out_of_range &_e) {
82051         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82052         return 0;
82053       }
82054
82055     } catch (std::out_of_range& e) {
82056       {
82057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82058       };
82059     } catch (std::exception& e) {
82060       {
82061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82062       };
82063     } catch (...) {
82064       {
82065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82066       };
82067     }
82068   }
82069   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
82070   return jresult;
82071 }
82072
82073
82074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
82075   void * jresult ;
82076   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82077   int arg2 ;
82078   std::pair< unsigned int,Dali::Actor > *result = 0 ;
82079
82080   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82081   arg2 = (int)jarg2;
82082   {
82083     try {
82084       try {
82085         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
82086       }
82087       catch(std::out_of_range &_e) {
82088         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82089         return 0;
82090       }
82091
82092     } catch (std::out_of_range& e) {
82093       {
82094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82095       };
82096     } catch (std::exception& e) {
82097       {
82098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82099       };
82100     } catch (...) {
82101       {
82102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82103       };
82104     }
82105   }
82106   jresult = (void *)result;
82107   return jresult;
82108 }
82109
82110
82111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
82112   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82113   int arg2 ;
82114   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
82115
82116   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82117   arg2 = (int)jarg2;
82118   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
82119   if (!arg3) {
82120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
82121     return ;
82122   }
82123   {
82124     try {
82125       try {
82126         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(arg1,arg2,(std::pair< unsigned int,Dali::Actor > const &)*arg3);
82127       }
82128       catch(std::out_of_range &_e) {
82129         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82130         return ;
82131       }
82132
82133     } catch (std::out_of_range& e) {
82134       {
82135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82136       };
82137     } catch (std::exception& e) {
82138       {
82139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82140       };
82141     } catch (...) {
82142       {
82143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82144       };
82145     }
82146   }
82147 }
82148
82149
82150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
82151   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82152   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
82153
82154   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82155   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
82156   if (!arg2) {
82157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
82158     return ;
82159   }
82160   {
82161     try {
82162       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(arg1,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg2);
82163     } catch (std::out_of_range& e) {
82164       {
82165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82166       };
82167     } catch (std::exception& e) {
82168       {
82169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82170       };
82171     } catch (...) {
82172       {
82173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82174       };
82175     }
82176   }
82177 }
82178
82179
82180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82181   void * jresult ;
82182   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82183   int arg2 ;
82184   int arg3 ;
82185   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
82186
82187   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82188   arg2 = (int)jarg2;
82189   arg3 = (int)jarg3;
82190   {
82191     try {
82192       try {
82193         result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(arg1,arg2,arg3);
82194       }
82195       catch(std::out_of_range &_e) {
82196         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82197         return 0;
82198       }
82199       catch(std::invalid_argument &_e) {
82200         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82201         return 0;
82202       }
82203
82204     } catch (std::out_of_range& e) {
82205       {
82206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82207       };
82208     } catch (std::exception& e) {
82209       {
82210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82211       };
82212     } catch (...) {
82213       {
82214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82215       };
82216     }
82217   }
82218   jresult = (void *)result;
82219   return jresult;
82220 }
82221
82222
82223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
82224   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82225   int arg2 ;
82226   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
82227
82228   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82229   arg2 = (int)jarg2;
82230   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
82231   if (!arg3) {
82232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
82233     return ;
82234   }
82235   {
82236     try {
82237       try {
82238         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(arg1,arg2,(std::pair< unsigned int,Dali::Actor > const &)*arg3);
82239       }
82240       catch(std::out_of_range &_e) {
82241         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82242         return ;
82243       }
82244
82245     } catch (std::out_of_range& e) {
82246       {
82247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82248       };
82249     } catch (std::exception& e) {
82250       {
82251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82252       };
82253     } catch (...) {
82254       {
82255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82256       };
82257     }
82258   }
82259 }
82260
82261
82262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82263   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82264   int arg2 ;
82265   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
82266
82267   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82268   arg2 = (int)jarg2;
82269   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
82270   if (!arg3) {
82271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
82272     return ;
82273   }
82274   {
82275     try {
82276       try {
82277         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg3);
82278       }
82279       catch(std::out_of_range &_e) {
82280         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82281         return ;
82282       }
82283
82284     } catch (std::out_of_range& e) {
82285       {
82286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82287       };
82288     } catch (std::exception& e) {
82289       {
82290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82291       };
82292     } catch (...) {
82293       {
82294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82295       };
82296     }
82297   }
82298 }
82299
82300
82301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
82302   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82303   int arg2 ;
82304
82305   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82306   arg2 = (int)jarg2;
82307   {
82308     try {
82309       try {
82310         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
82311       }
82312       catch(std::out_of_range &_e) {
82313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82314         return ;
82315       }
82316
82317     } catch (std::out_of_range& e) {
82318       {
82319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82320       };
82321     } catch (std::exception& e) {
82322       {
82323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82324       };
82325     } catch (...) {
82326       {
82327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82328       };
82329     }
82330   }
82331 }
82332
82333
82334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82335   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82336   int arg2 ;
82337   int arg3 ;
82338
82339   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82340   arg2 = (int)jarg2;
82341   arg3 = (int)jarg3;
82342   {
82343     try {
82344       try {
82345         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
82346       }
82347       catch(std::out_of_range &_e) {
82348         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82349         return ;
82350       }
82351       catch(std::invalid_argument &_e) {
82352         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82353         return ;
82354       }
82355
82356     } catch (std::out_of_range& e) {
82357       {
82358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82359       };
82360     } catch (std::exception& e) {
82361       {
82362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82363       };
82364     } catch (...) {
82365       {
82366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82367       };
82368     }
82369   }
82370 }
82371
82372
82373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
82374   void * jresult ;
82375   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
82376   int arg2 ;
82377   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
82378
82379   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
82380   if (!arg1) {
82381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
82382     return 0;
82383   }
82384   arg2 = (int)jarg2;
82385   {
82386     try {
82387       try {
82388         result = (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 &)*arg1,arg2);
82389       }
82390       catch(std::out_of_range &_e) {
82391         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82392         return 0;
82393       }
82394
82395     } catch (std::out_of_range& e) {
82396       {
82397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82398       };
82399     } catch (std::exception& e) {
82400       {
82401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82402       };
82403     } catch (...) {
82404       {
82405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82406       };
82407     }
82408   }
82409   jresult = (void *)result;
82410   return jresult;
82411 }
82412
82413
82414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
82415   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82416
82417   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82418   {
82419     try {
82420       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
82421     } catch (std::out_of_range& e) {
82422       {
82423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82424       };
82425     } catch (std::exception& e) {
82426       {
82427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82428       };
82429     } catch (...) {
82430       {
82431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82432       };
82433     }
82434   }
82435 }
82436
82437
82438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82439   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82440   int arg2 ;
82441   int arg3 ;
82442
82443   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82444   arg2 = (int)jarg2;
82445   arg3 = (int)jarg3;
82446   {
82447     try {
82448       try {
82449         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82450       }
82451       catch(std::out_of_range &_e) {
82452         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82453         return ;
82454       }
82455       catch(std::invalid_argument &_e) {
82456         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82457         return ;
82458       }
82459
82460     } catch (std::out_of_range& e) {
82461       {
82462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82463       };
82464     } catch (std::exception& e) {
82465       {
82466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82467       };
82468     } catch (...) {
82469       {
82470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82471       };
82472     }
82473   }
82474 }
82475
82476
82477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82478   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82479   int arg2 ;
82480   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
82481
82482   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82483   arg2 = (int)jarg2;
82484   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
82485   if (!arg3) {
82486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
82487     return ;
82488   }
82489   {
82490     try {
82491       try {
82492         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg3);
82493       }
82494       catch(std::out_of_range &_e) {
82495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82496         return ;
82497       }
82498
82499     } catch (std::out_of_range& e) {
82500       {
82501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82502       };
82503     } catch (std::exception& e) {
82504       {
82505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82506       };
82507     } catch (...) {
82508       {
82509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82510       };
82511     }
82512   }
82513 }
82514
82515
82516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
82517   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
82518
82519   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
82520   {
82521     try {
82522       delete arg1;
82523     } catch (std::out_of_range& e) {
82524       {
82525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82526       };
82527     } catch (std::exception& e) {
82528       {
82529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82530       };
82531     } catch (...) {
82532       {
82533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82534       };
82535     }
82536   }
82537 }
82538
82539
82540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
82541   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82542
82543   arg1 = (std::vector< Dali::Actor > *)jarg1;
82544   {
82545     try {
82546       (arg1)->clear();
82547     } catch (std::out_of_range& e) {
82548       {
82549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82550       };
82551     } catch (std::exception& e) {
82552       {
82553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82554       };
82555     } catch (...) {
82556       {
82557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82558       };
82559     }
82560   }
82561 }
82562
82563
82564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
82565   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82566   Dali::Actor *arg2 = 0 ;
82567
82568   arg1 = (std::vector< Dali::Actor > *)jarg1;
82569   arg2 = (Dali::Actor *)jarg2;
82570   if (!arg2) {
82571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82572     return ;
82573   }
82574   {
82575     try {
82576       (arg1)->push_back((Dali::Actor const &)*arg2);
82577     } catch (std::out_of_range& e) {
82578       {
82579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82580       };
82581     } catch (std::exception& e) {
82582       {
82583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82584       };
82585     } catch (...) {
82586       {
82587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82588       };
82589     }
82590   }
82591 }
82592
82593
82594 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
82595   unsigned long jresult ;
82596   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82597   std::vector< Dali::Actor >::size_type result;
82598
82599   arg1 = (std::vector< Dali::Actor > *)jarg1;
82600   {
82601     try {
82602       result = ((std::vector< Dali::Actor > const *)arg1)->size();
82603     } catch (std::out_of_range& e) {
82604       {
82605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82606       };
82607     } catch (std::exception& e) {
82608       {
82609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82610       };
82611     } catch (...) {
82612       {
82613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82614       };
82615     }
82616   }
82617   jresult = (unsigned long)result;
82618   return jresult;
82619 }
82620
82621
82622 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
82623   unsigned long jresult ;
82624   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82625   std::vector< Dali::Actor >::size_type result;
82626
82627   arg1 = (std::vector< Dali::Actor > *)jarg1;
82628   {
82629     try {
82630       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
82631     } catch (std::out_of_range& e) {
82632       {
82633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82634       };
82635     } catch (std::exception& e) {
82636       {
82637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82638       };
82639     } catch (...) {
82640       {
82641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82642       };
82643     }
82644   }
82645   jresult = (unsigned long)result;
82646   return jresult;
82647 }
82648
82649
82650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
82651   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82652   std::vector< Dali::Actor >::size_type arg2 ;
82653
82654   arg1 = (std::vector< Dali::Actor > *)jarg1;
82655   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
82656   {
82657     try {
82658       (arg1)->reserve(arg2);
82659     } catch (std::out_of_range& e) {
82660       {
82661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82662       };
82663     } catch (std::exception& e) {
82664       {
82665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82666       };
82667     } catch (...) {
82668       {
82669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82670       };
82671     }
82672   }
82673 }
82674
82675
82676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
82677   void * jresult ;
82678   std::vector< Dali::Actor > *result = 0 ;
82679
82680   {
82681     try {
82682       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
82683     } catch (std::out_of_range& e) {
82684       {
82685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82686       };
82687     } catch (std::exception& e) {
82688       {
82689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82690       };
82691     } catch (...) {
82692       {
82693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82694       };
82695     }
82696   }
82697   jresult = (void *)result;
82698   return jresult;
82699 }
82700
82701
82702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
82703   void * jresult ;
82704   std::vector< Dali::Actor > *arg1 = 0 ;
82705   std::vector< Dali::Actor > *result = 0 ;
82706
82707   arg1 = (std::vector< Dali::Actor > *)jarg1;
82708   if (!arg1) {
82709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82710     return 0;
82711   }
82712   {
82713     try {
82714       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
82715     } catch (std::out_of_range& e) {
82716       {
82717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82718       };
82719     } catch (std::exception& e) {
82720       {
82721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82722       };
82723     } catch (...) {
82724       {
82725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82726       };
82727     }
82728   }
82729   jresult = (void *)result;
82730   return jresult;
82731 }
82732
82733
82734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
82735   void * jresult ;
82736   int arg1 ;
82737   std::vector< Dali::Actor > *result = 0 ;
82738
82739   arg1 = (int)jarg1;
82740   {
82741     try {
82742       try {
82743         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
82744       }
82745       catch(std::out_of_range &_e) {
82746         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82747         return 0;
82748       }
82749
82750     } catch (std::out_of_range& e) {
82751       {
82752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82753       };
82754     } catch (std::exception& e) {
82755       {
82756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82757       };
82758     } catch (...) {
82759       {
82760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82761       };
82762     }
82763   }
82764   jresult = (void *)result;
82765   return jresult;
82766 }
82767
82768
82769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
82770   void * jresult ;
82771   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82772   int arg2 ;
82773   Dali::Actor result;
82774
82775   arg1 = (std::vector< Dali::Actor > *)jarg1;
82776   arg2 = (int)jarg2;
82777   {
82778     try {
82779       try {
82780         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
82781       }
82782       catch(std::out_of_range &_e) {
82783         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82784         return 0;
82785       }
82786
82787     } catch (std::out_of_range& e) {
82788       {
82789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82790       };
82791     } catch (std::exception& e) {
82792       {
82793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82794       };
82795     } catch (...) {
82796       {
82797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82798       };
82799     }
82800   }
82801   jresult = new Dali::Actor((const Dali::Actor &)result);
82802   return jresult;
82803 }
82804
82805
82806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
82807   void * jresult ;
82808   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82809   int arg2 ;
82810   Dali::Actor *result = 0 ;
82811
82812   arg1 = (std::vector< Dali::Actor > *)jarg1;
82813   arg2 = (int)jarg2;
82814   {
82815     try {
82816       try {
82817         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
82818       }
82819       catch(std::out_of_range &_e) {
82820         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82821         return 0;
82822       }
82823
82824     } catch (std::out_of_range& e) {
82825       {
82826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82827       };
82828     } catch (std::exception& e) {
82829       {
82830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82831       };
82832     } catch (...) {
82833       {
82834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82835       };
82836     }
82837   }
82838   jresult = (void *)result;
82839   return jresult;
82840 }
82841
82842
82843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
82844   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82845   int arg2 ;
82846   Dali::Actor *arg3 = 0 ;
82847
82848   arg1 = (std::vector< Dali::Actor > *)jarg1;
82849   arg2 = (int)jarg2;
82850   arg3 = (Dali::Actor *)jarg3;
82851   if (!arg3) {
82852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82853     return ;
82854   }
82855   {
82856     try {
82857       try {
82858         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
82859       }
82860       catch(std::out_of_range &_e) {
82861         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82862         return ;
82863       }
82864
82865     } catch (std::out_of_range& e) {
82866       {
82867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82868       };
82869     } catch (std::exception& e) {
82870       {
82871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82872       };
82873     } catch (...) {
82874       {
82875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82876       };
82877     }
82878   }
82879 }
82880
82881
82882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
82883   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82884   std::vector< Dali::Actor > *arg2 = 0 ;
82885
82886   arg1 = (std::vector< Dali::Actor > *)jarg1;
82887   arg2 = (std::vector< Dali::Actor > *)jarg2;
82888   if (!arg2) {
82889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82890     return ;
82891   }
82892   {
82893     try {
82894       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
82895     } catch (std::out_of_range& e) {
82896       {
82897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82898       };
82899     } catch (std::exception& e) {
82900       {
82901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82902       };
82903     } catch (...) {
82904       {
82905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82906       };
82907     }
82908   }
82909 }
82910
82911
82912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82913   void * jresult ;
82914   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82915   int arg2 ;
82916   int arg3 ;
82917   std::vector< Dali::Actor > *result = 0 ;
82918
82919   arg1 = (std::vector< Dali::Actor > *)jarg1;
82920   arg2 = (int)jarg2;
82921   arg3 = (int)jarg3;
82922   {
82923     try {
82924       try {
82925         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
82926       }
82927       catch(std::out_of_range &_e) {
82928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82929         return 0;
82930       }
82931       catch(std::invalid_argument &_e) {
82932         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82933         return 0;
82934       }
82935
82936     } catch (std::out_of_range& e) {
82937       {
82938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82939       };
82940     } catch (std::exception& e) {
82941       {
82942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82943       };
82944     } catch (...) {
82945       {
82946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82947       };
82948     }
82949   }
82950   jresult = (void *)result;
82951   return jresult;
82952 }
82953
82954
82955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
82956   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82957   int arg2 ;
82958   Dali::Actor *arg3 = 0 ;
82959
82960   arg1 = (std::vector< Dali::Actor > *)jarg1;
82961   arg2 = (int)jarg2;
82962   arg3 = (Dali::Actor *)jarg3;
82963   if (!arg3) {
82964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82965     return ;
82966   }
82967   {
82968     try {
82969       try {
82970         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
82971       }
82972       catch(std::out_of_range &_e) {
82973         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82974         return ;
82975       }
82976
82977     } catch (std::out_of_range& e) {
82978       {
82979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82980       };
82981     } catch (std::exception& e) {
82982       {
82983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82984       };
82985     } catch (...) {
82986       {
82987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82988       };
82989     }
82990   }
82991 }
82992
82993
82994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82995   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82996   int arg2 ;
82997   std::vector< Dali::Actor > *arg3 = 0 ;
82998
82999   arg1 = (std::vector< Dali::Actor > *)jarg1;
83000   arg2 = (int)jarg2;
83001   arg3 = (std::vector< Dali::Actor > *)jarg3;
83002   if (!arg3) {
83003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
83004     return ;
83005   }
83006   {
83007     try {
83008       try {
83009         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
83010       }
83011       catch(std::out_of_range &_e) {
83012         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83013         return ;
83014       }
83015
83016     } catch (std::out_of_range& e) {
83017       {
83018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83019       };
83020     } catch (std::exception& e) {
83021       {
83022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83023       };
83024     } catch (...) {
83025       {
83026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83027       };
83028     }
83029   }
83030 }
83031
83032
83033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
83034   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
83035   int arg2 ;
83036
83037   arg1 = (std::vector< Dali::Actor > *)jarg1;
83038   arg2 = (int)jarg2;
83039   {
83040     try {
83041       try {
83042         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
83043       }
83044       catch(std::out_of_range &_e) {
83045         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83046         return ;
83047       }
83048
83049     } catch (std::out_of_range& e) {
83050       {
83051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83052       };
83053     } catch (std::exception& e) {
83054       {
83055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83056       };
83057     } catch (...) {
83058       {
83059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83060       };
83061     }
83062   }
83063 }
83064
83065
83066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
83067   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
83068   int arg2 ;
83069   int arg3 ;
83070
83071   arg1 = (std::vector< Dali::Actor > *)jarg1;
83072   arg2 = (int)jarg2;
83073   arg3 = (int)jarg3;
83074   {
83075     try {
83076       try {
83077         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
83078       }
83079       catch(std::out_of_range &_e) {
83080         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83081         return ;
83082       }
83083       catch(std::invalid_argument &_e) {
83084         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83085         return ;
83086       }
83087
83088     } catch (std::out_of_range& e) {
83089       {
83090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83091       };
83092     } catch (std::exception& e) {
83093       {
83094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83095       };
83096     } catch (...) {
83097       {
83098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83099       };
83100     }
83101   }
83102 }
83103
83104
83105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
83106   void * jresult ;
83107   Dali::Actor *arg1 = 0 ;
83108   int arg2 ;
83109   std::vector< Dali::Actor > *result = 0 ;
83110
83111   arg1 = (Dali::Actor *)jarg1;
83112   if (!arg1) {
83113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
83114     return 0;
83115   }
83116   arg2 = (int)jarg2;
83117   {
83118     try {
83119       try {
83120         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
83121       }
83122       catch(std::out_of_range &_e) {
83123         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83124         return 0;
83125       }
83126
83127     } catch (std::out_of_range& e) {
83128       {
83129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83130       };
83131     } catch (std::exception& e) {
83132       {
83133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83134       };
83135     } catch (...) {
83136       {
83137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83138       };
83139     }
83140   }
83141   jresult = (void *)result;
83142   return jresult;
83143 }
83144
83145
83146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
83147   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
83148
83149   arg1 = (std::vector< Dali::Actor > *)jarg1;
83150   {
83151     try {
83152       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
83153     } catch (std::out_of_range& e) {
83154       {
83155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83156       };
83157     } catch (std::exception& e) {
83158       {
83159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83160       };
83161     } catch (...) {
83162       {
83163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83164       };
83165     }
83166   }
83167 }
83168
83169
83170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
83171   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
83172   int arg2 ;
83173   int arg3 ;
83174
83175   arg1 = (std::vector< Dali::Actor > *)jarg1;
83176   arg2 = (int)jarg2;
83177   arg3 = (int)jarg3;
83178   {
83179     try {
83180       try {
83181         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
83182       }
83183       catch(std::out_of_range &_e) {
83184         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83185         return ;
83186       }
83187       catch(std::invalid_argument &_e) {
83188         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83189         return ;
83190       }
83191
83192     } catch (std::out_of_range& e) {
83193       {
83194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83195       };
83196     } catch (std::exception& e) {
83197       {
83198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83199       };
83200     } catch (...) {
83201       {
83202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83203       };
83204     }
83205   }
83206 }
83207
83208
83209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
83210   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
83211   int arg2 ;
83212   std::vector< Dali::Actor > *arg3 = 0 ;
83213
83214   arg1 = (std::vector< Dali::Actor > *)jarg1;
83215   arg2 = (int)jarg2;
83216   arg3 = (std::vector< Dali::Actor > *)jarg3;
83217   if (!arg3) {
83218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
83219     return ;
83220   }
83221   {
83222     try {
83223       try {
83224         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
83225       }
83226       catch(std::out_of_range &_e) {
83227         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83228         return ;
83229       }
83230
83231     } catch (std::out_of_range& e) {
83232       {
83233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83234       };
83235     } catch (std::exception& e) {
83236       {
83237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83238       };
83239     } catch (...) {
83240       {
83241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83242       };
83243     }
83244   }
83245 }
83246
83247
83248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
83249   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
83250
83251   arg1 = (std::vector< Dali::Actor > *)jarg1;
83252   {
83253     try {
83254       delete arg1;
83255     } catch (std::out_of_range& e) {
83256       {
83257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83258       };
83259     } catch (std::exception& e) {
83260       {
83261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83262       };
83263     } catch (...) {
83264       {
83265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83266       };
83267     }
83268   }
83269 }
83270
83271
83272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
83273   unsigned int jresult ;
83274   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
83275   bool result;
83276
83277   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
83278   {
83279     try {
83280       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
83281     } catch (std::out_of_range& e) {
83282       {
83283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83284       };
83285     } catch (std::exception& e) {
83286       {
83287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83288       };
83289     } catch (...) {
83290       {
83291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83292       };
83293     }
83294   }
83295   jresult = result;
83296   return jresult;
83297 }
83298
83299
83300 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
83301   unsigned long jresult ;
83302   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
83303   std::size_t result;
83304
83305   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
83306   {
83307     try {
83308       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
83309     } catch (std::out_of_range& e) {
83310       {
83311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83312       };
83313     } catch (std::exception& e) {
83314       {
83315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83316       };
83317     } catch (...) {
83318       {
83319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83320       };
83321     }
83322   }
83323   jresult = (unsigned long)result;
83324   return jresult;
83325 }
83326
83327
83328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
83329   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
83330   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
83331
83332   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
83333   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
83334   {
83335     try {
83336       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
83337     } catch (std::out_of_range& e) {
83338       {
83339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83340       };
83341     } catch (std::exception& e) {
83342       {
83343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83344       };
83345     } catch (...) {
83346       {
83347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83348       };
83349     }
83350   }
83351 }
83352
83353
83354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
83355   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
83356   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
83357
83358   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
83359   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
83360   {
83361     try {
83362       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
83363     } catch (std::out_of_range& e) {
83364       {
83365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83366       };
83367     } catch (std::exception& e) {
83368       {
83369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83370       };
83371     } catch (...) {
83372       {
83373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83374       };
83375     }
83376   }
83377 }
83378
83379
83380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
83381   unsigned int jresult ;
83382   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
83383   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
83384   bool result;
83385
83386   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
83387   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
83388   if (!arg2) {
83389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
83390     return 0;
83391   }
83392   {
83393     try {
83394       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
83395     } catch (std::out_of_range& e) {
83396       {
83397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83398       };
83399     } catch (std::exception& e) {
83400       {
83401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83402       };
83403     } catch (...) {
83404       {
83405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83406       };
83407     }
83408   }
83409   jresult = result;
83410   return jresult;
83411 }
83412
83413
83414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
83415   void * jresult ;
83416   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
83417
83418   {
83419     try {
83420       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
83421     } catch (std::out_of_range& e) {
83422       {
83423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83424       };
83425     } catch (std::exception& e) {
83426       {
83427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83428       };
83429     } catch (...) {
83430       {
83431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83432       };
83433     }
83434   }
83435   jresult = (void *)result;
83436   return jresult;
83437 }
83438
83439
83440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
83441   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
83442
83443   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
83444   {
83445     try {
83446       delete arg1;
83447     } catch (std::out_of_range& e) {
83448       {
83449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83450       };
83451     } catch (std::exception& e) {
83452       {
83453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83454       };
83455     } catch (...) {
83456       {
83457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83458       };
83459     }
83460   }
83461 }
83462
83463
83464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionScrollSignal_Empty(void * jarg1) {
83465   unsigned int jresult ;
83466   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
83467   bool result;
83468
83469   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
83470   {
83471     try {
83472       result = (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 *)arg1);
83473     } catch (std::out_of_range& e) {
83474       {
83475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83476       };
83477     } catch (std::exception& e) {
83478       {
83479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83480       };
83481     } catch (...) {
83482       {
83483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83484       };
83485     }
83486   }
83487   jresult = result;
83488   return jresult;
83489 }
83490
83491
83492 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionScrollSignal_GetConnectionCount(void * jarg1) {
83493   unsigned long jresult ;
83494   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
83495   std::size_t result;
83496
83497   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
83498   {
83499     try {
83500       result = 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 *)arg1);
83501     } catch (std::out_of_range& e) {
83502       {
83503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83504       };
83505     } catch (std::exception& e) {
83506       {
83507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83508       };
83509     } catch (...) {
83510       {
83511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83512       };
83513     }
83514   }
83515   jresult = (unsigned long)result;
83516   return jresult;
83517 }
83518
83519
83520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionScrollSignal_Connect(void * jarg1, void * jarg2) {
83521   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
83522   bool (*arg2)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)) 0 ;
83523
83524   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
83525   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &))jarg2;
83526   {
83527     try {
83528       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
83529     } catch (std::out_of_range& e) {
83530       {
83531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83532       };
83533     } catch (std::exception& e) {
83534       {
83535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83536       };
83537     } catch (...) {
83538       {
83539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83540       };
83541     }
83542   }
83543 }
83544
83545
83546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionScrollSignal_Disconnect(void * jarg1, void * jarg2) {
83547   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
83548   bool (*arg2)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)) 0 ;
83549
83550   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
83551   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &))jarg2;
83552   {
83553     try {
83554       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
83555     } catch (std::out_of_range& e) {
83556       {
83557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83558       };
83559     } catch (std::exception& e) {
83560       {
83561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83562       };
83563     } catch (...) {
83564       {
83565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83566       };
83567     }
83568   }
83569 }
83570
83571
83572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionScrollSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
83573   unsigned int jresult ;
83574   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
83575   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
83576   Dali::TouchEvent *arg3 = 0 ;
83577   bool result;
83578
83579   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
83580   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
83581   if (!arg2) {
83582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
83583     return 0;
83584   }
83585   arg3 = (Dali::TouchEvent *)jarg3;
83586   if (!arg3) {
83587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
83588     return 0;
83589   }
83590   {
83591     try {
83592       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::TouchEvent const &)*arg3);
83593     } catch (std::out_of_range& e) {
83594       {
83595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83596       };
83597     } catch (std::exception& e) {
83598       {
83599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83600       };
83601     } catch (...) {
83602       {
83603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83604       };
83605     }
83606   }
83607   jresult = result;
83608   return jresult;
83609 }
83610
83611
83612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionScrollSignal() {
83613   void * jresult ;
83614   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *result = 0 ;
83615
83616   {
83617     try {
83618       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) >();
83619     } catch (std::out_of_range& e) {
83620       {
83621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83622       };
83623     } catch (std::exception& e) {
83624       {
83625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83626       };
83627     } catch (...) {
83628       {
83629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83630       };
83631     }
83632   }
83633   jresult = (void *)result;
83634   return jresult;
83635 }
83636
83637
83638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionScrollSignal(void * jarg1) {
83639   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
83640
83641   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
83642   {
83643     try {
83644       delete arg1;
83645     } catch (std::out_of_range& e) {
83646       {
83647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83648       };
83649     } catch (std::exception& e) {
83650       {
83651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83652       };
83653     } catch (...) {
83654       {
83655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83656       };
83657     }
83658   }
83659 }
83660
83661
83662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
83663   unsigned int jresult ;
83664   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
83665   bool result;
83666
83667   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
83668   {
83669     try {
83670       result = (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 *)arg1);
83671     } catch (std::out_of_range& e) {
83672       {
83673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83674       };
83675     } catch (std::exception& e) {
83676       {
83677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83678       };
83679     } catch (...) {
83680       {
83681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83682       };
83683     }
83684   }
83685   jresult = result;
83686   return jresult;
83687 }
83688
83689
83690 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
83691   unsigned long jresult ;
83692   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
83693   std::size_t result;
83694
83695   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
83696   {
83697     try {
83698       result = 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 *)arg1);
83699     } catch (std::out_of_range& e) {
83700       {
83701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83702       };
83703     } catch (std::exception& e) {
83704       {
83705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83706       };
83707     } catch (...) {
83708       {
83709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83710       };
83711     }
83712   }
83713   jresult = (unsigned long)result;
83714   return jresult;
83715 }
83716
83717
83718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
83719   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
83720   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
83721
83722   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
83723   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
83724   {
83725     try {
83726       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
83727     } catch (std::out_of_range& e) {
83728       {
83729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83730       };
83731     } catch (std::exception& e) {
83732       {
83733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83734       };
83735     } catch (...) {
83736       {
83737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83738       };
83739     }
83740   }
83741 }
83742
83743
83744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
83745   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
83746   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
83747
83748   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
83749   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
83750   {
83751     try {
83752       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
83753     } catch (std::out_of_range& e) {
83754       {
83755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83756       };
83757     } catch (std::exception& e) {
83758       {
83759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83760       };
83761     } catch (...) {
83762       {
83763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83764       };
83765     }
83766   }
83767 }
83768
83769
83770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
83771   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
83772   Dali::Actor arg2 ;
83773   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
83774   Dali::Actor *argp2 ;
83775
83776   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
83777   argp2 = (Dali::Actor *)jarg2;
83778   if (!argp2) {
83779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83780     return ;
83781   }
83782   arg2 = *argp2;
83783   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
83784   {
83785     try {
83786       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
83787     } catch (std::out_of_range& e) {
83788       {
83789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83790       };
83791     } catch (std::exception& e) {
83792       {
83793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83794       };
83795     } catch (...) {
83796       {
83797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83798       };
83799     }
83800   }
83801 }
83802
83803
83804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
83805   void * jresult ;
83806   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
83807
83808   {
83809     try {
83810       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
83811     } catch (std::out_of_range& e) {
83812       {
83813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83814       };
83815     } catch (std::exception& e) {
83816       {
83817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83818       };
83819     } catch (...) {
83820       {
83821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83822       };
83823     }
83824   }
83825   jresult = (void *)result;
83826   return jresult;
83827 }
83828
83829
83830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
83831   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
83832
83833   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
83834   {
83835     try {
83836       delete arg1;
83837     } catch (std::out_of_range& e) {
83838       {
83839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83840       };
83841     } catch (std::exception& e) {
83842       {
83843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83844       };
83845     } catch (...) {
83846       {
83847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83848       };
83849     }
83850   }
83851 }
83852
83853
83854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
83855   unsigned int jresult ;
83856   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83857   bool result;
83858
83859   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83860   {
83861     try {
83862       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
83863     } catch (std::out_of_range& e) {
83864       {
83865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83866       };
83867     } catch (std::exception& e) {
83868       {
83869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83870       };
83871     } catch (...) {
83872       {
83873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83874       };
83875     }
83876   }
83877   jresult = result;
83878   return jresult;
83879 }
83880
83881
83882 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
83883   unsigned long jresult ;
83884   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83885   std::size_t result;
83886
83887   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83888   {
83889     try {
83890       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
83891     } catch (std::out_of_range& e) {
83892       {
83893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83894       };
83895     } catch (std::exception& e) {
83896       {
83897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83898       };
83899     } catch (...) {
83900       {
83901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83902       };
83903     }
83904   }
83905   jresult = (unsigned long)result;
83906   return jresult;
83907 }
83908
83909
83910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
83911   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83912   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
83913
83914   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83915   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
83916   {
83917     try {
83918       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
83919     } catch (std::out_of_range& e) {
83920       {
83921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83922       };
83923     } catch (std::exception& e) {
83924       {
83925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83926       };
83927     } catch (...) {
83928       {
83929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83930       };
83931     }
83932   }
83933 }
83934
83935
83936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83937   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83938   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
83939
83940   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83941   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
83942   {
83943     try {
83944       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
83945     } catch (std::out_of_range& e) {
83946       {
83947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83948       };
83949     } catch (std::exception& e) {
83950       {
83951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83952       };
83953     } catch (...) {
83954       {
83955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83956       };
83957     }
83958   }
83959 }
83960
83961
83962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
83963   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83964   Dali::Actor arg2 ;
83965   Dali::Actor arg3 ;
83966   Dali::Actor *argp2 ;
83967   Dali::Actor *argp3 ;
83968
83969   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83970   argp2 = (Dali::Actor *)jarg2;
83971   if (!argp2) {
83972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83973     return ;
83974   }
83975   arg2 = *argp2;
83976   argp3 = (Dali::Actor *)jarg3;
83977   if (!argp3) {
83978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83979     return ;
83980   }
83981   arg3 = *argp3;
83982   {
83983     try {
83984       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
83985     } catch (std::out_of_range& e) {
83986       {
83987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83988       };
83989     } catch (std::exception& e) {
83990       {
83991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83992       };
83993     } catch (...) {
83994       {
83995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83996       };
83997     }
83998   }
83999 }
84000
84001
84002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
84003   void * jresult ;
84004   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
84005
84006   {
84007     try {
84008       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
84009     } catch (std::out_of_range& e) {
84010       {
84011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84012       };
84013     } catch (std::exception& e) {
84014       {
84015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84016       };
84017     } catch (...) {
84018       {
84019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84020       };
84021     }
84022   }
84023   jresult = (void *)result;
84024   return jresult;
84025 }
84026
84027
84028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
84029   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
84030
84031   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
84032   {
84033     try {
84034       delete arg1;
84035     } catch (std::out_of_range& e) {
84036       {
84037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84038       };
84039     } catch (std::exception& e) {
84040       {
84041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84042       };
84043     } catch (...) {
84044       {
84045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84046       };
84047     }
84048   }
84049 }
84050
84051
84052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
84053   unsigned int jresult ;
84054   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
84055   bool result;
84056
84057   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
84058   {
84059     try {
84060       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
84061     } catch (std::out_of_range& e) {
84062       {
84063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84064       };
84065     } catch (std::exception& e) {
84066       {
84067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84068       };
84069     } catch (...) {
84070       {
84071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84072       };
84073     }
84074   }
84075   jresult = result;
84076   return jresult;
84077 }
84078
84079
84080 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
84081   unsigned long jresult ;
84082   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
84083   std::size_t result;
84084
84085   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
84086   {
84087     try {
84088       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
84089     } catch (std::out_of_range& e) {
84090       {
84091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84092       };
84093     } catch (std::exception& e) {
84094       {
84095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84096       };
84097     } catch (...) {
84098       {
84099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84100       };
84101     }
84102   }
84103   jresult = (unsigned long)result;
84104   return jresult;
84105 }
84106
84107
84108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
84109   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
84110   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
84111
84112   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
84113   arg2 = (void (*)(Dali::Actor,bool))jarg2;
84114   {
84115     try {
84116       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
84117     } catch (std::out_of_range& e) {
84118       {
84119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84120       };
84121     } catch (std::exception& e) {
84122       {
84123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84124       };
84125     } catch (...) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84128       };
84129     }
84130   }
84131 }
84132
84133
84134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
84135   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
84136   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
84137
84138   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
84139   arg2 = (void (*)(Dali::Actor,bool))jarg2;
84140   {
84141     try {
84142       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
84143     } catch (std::out_of_range& e) {
84144       {
84145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84146       };
84147     } catch (std::exception& e) {
84148       {
84149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84150       };
84151     } catch (...) {
84152       {
84153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84154       };
84155     }
84156   }
84157 }
84158
84159
84160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
84161   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
84162   Dali::Actor arg2 ;
84163   bool arg3 ;
84164   Dali::Actor *argp2 ;
84165
84166   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
84167   argp2 = (Dali::Actor *)jarg2;
84168   if (!argp2) {
84169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84170     return ;
84171   }
84172   arg2 = *argp2;
84173   arg3 = jarg3 ? true : false;
84174   {
84175     try {
84176       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
84177     } catch (std::out_of_range& e) {
84178       {
84179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84180       };
84181     } catch (std::exception& e) {
84182       {
84183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84184       };
84185     } catch (...) {
84186       {
84187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84188       };
84189     }
84190   }
84191 }
84192
84193
84194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
84195   void * jresult ;
84196   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
84197
84198   {
84199     try {
84200       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
84201     } catch (std::out_of_range& e) {
84202       {
84203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84204       };
84205     } catch (std::exception& e) {
84206       {
84207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84208       };
84209     } catch (...) {
84210       {
84211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84212       };
84213     }
84214   }
84215   jresult = (void *)result;
84216   return jresult;
84217 }
84218
84219
84220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
84221   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
84222
84223   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
84224   {
84225     try {
84226       delete arg1;
84227     } catch (std::out_of_range& e) {
84228       {
84229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84230       };
84231     } catch (std::exception& e) {
84232       {
84233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84234       };
84235     } catch (...) {
84236       {
84237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84238       };
84239     }
84240   }
84241 }
84242
84243
84244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
84245   unsigned int jresult ;
84246   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
84247   bool result;
84248
84249   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
84250   {
84251     try {
84252       result = (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 *)arg1);
84253     } catch (std::out_of_range& e) {
84254       {
84255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84256       };
84257     } catch (std::exception& e) {
84258       {
84259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84260       };
84261     } catch (...) {
84262       {
84263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84264       };
84265     }
84266   }
84267   jresult = result;
84268   return jresult;
84269 }
84270
84271
84272 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
84273   unsigned long jresult ;
84274   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
84275   std::size_t result;
84276
84277   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
84278   {
84279     try {
84280       result = 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 *)arg1);
84281     } catch (std::out_of_range& e) {
84282       {
84283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84284       };
84285     } catch (std::exception& e) {
84286       {
84287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84288       };
84289     } catch (...) {
84290       {
84291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84292       };
84293     }
84294   }
84295   jresult = (unsigned long)result;
84296   return jresult;
84297 }
84298
84299
84300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
84301   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
84302   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
84303
84304   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
84305   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
84306   {
84307     try {
84308       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
84309     } catch (std::out_of_range& e) {
84310       {
84311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84312       };
84313     } catch (std::exception& e) {
84314       {
84315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84316       };
84317     } catch (...) {
84318       {
84319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84320       };
84321     }
84322   }
84323 }
84324
84325
84326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
84327   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
84328   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
84329
84330   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
84331   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
84332   {
84333     try {
84334       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
84335     } catch (std::out_of_range& e) {
84336       {
84337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84338       };
84339     } catch (std::exception& e) {
84340       {
84341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84342       };
84343     } catch (...) {
84344       {
84345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84346       };
84347     }
84348   }
84349 }
84350
84351
84352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
84353   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
84354   Dali::Toolkit::StyleManager arg2 ;
84355   Dali::StyleChange::Type arg3 ;
84356   Dali::Toolkit::StyleManager *argp2 ;
84357
84358   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
84359   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
84360   if (!argp2) {
84361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
84362     return ;
84363   }
84364   arg2 = *argp2;
84365   arg3 = (Dali::StyleChange::Type)jarg3;
84366   {
84367     try {
84368       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
84369     } catch (std::out_of_range& e) {
84370       {
84371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84372       };
84373     } catch (std::exception& e) {
84374       {
84375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84376       };
84377     } catch (...) {
84378       {
84379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84380       };
84381     }
84382   }
84383 }
84384
84385
84386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
84387   void * jresult ;
84388   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
84389
84390   {
84391     try {
84392       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
84393     } catch (std::out_of_range& e) {
84394       {
84395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84396       };
84397     } catch (std::exception& e) {
84398       {
84399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84400       };
84401     } catch (...) {
84402       {
84403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84404       };
84405     }
84406   }
84407   jresult = (void *)result;
84408   return jresult;
84409 }
84410
84411
84412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
84413   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
84414
84415   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
84416   {
84417     try {
84418       delete arg1;
84419     } catch (std::out_of_range& e) {
84420       {
84421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84422       };
84423     } catch (std::exception& e) {
84424       {
84425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84426       };
84427     } catch (...) {
84428       {
84429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84430       };
84431     }
84432   }
84433 }
84434
84435
84436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
84437   unsigned int jresult ;
84438   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
84439   bool result;
84440
84441   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
84442   {
84443     try {
84444       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
84445     } catch (std::out_of_range& e) {
84446       {
84447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84448       };
84449     } catch (std::exception& e) {
84450       {
84451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84452       };
84453     } catch (...) {
84454       {
84455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84456       };
84457     }
84458   }
84459   jresult = result;
84460   return jresult;
84461 }
84462
84463
84464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
84465   unsigned long jresult ;
84466   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
84467   std::size_t result;
84468
84469   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
84470   {
84471     try {
84472       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
84473     } catch (std::out_of_range& e) {
84474       {
84475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84476       };
84477     } catch (std::exception& e) {
84478       {
84479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (...) {
84482       {
84483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84484       };
84485     }
84486   }
84487   jresult = (unsigned long)result;
84488   return jresult;
84489 }
84490
84491
84492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
84493   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
84494   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
84495
84496   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
84497   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
84498   {
84499     try {
84500       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
84501     } catch (std::out_of_range& e) {
84502       {
84503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84504       };
84505     } catch (std::exception& e) {
84506       {
84507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84508       };
84509     } catch (...) {
84510       {
84511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84512       };
84513     }
84514   }
84515 }
84516
84517
84518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
84519   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
84520   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
84521
84522   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
84523   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
84524   {
84525     try {
84526       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
84527     } catch (std::out_of_range& e) {
84528       {
84529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84530       };
84531     } catch (std::exception& e) {
84532       {
84533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84534       };
84535     } catch (...) {
84536       {
84537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84538       };
84539     }
84540   }
84541 }
84542
84543
84544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
84545   unsigned int jresult ;
84546   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
84547   Dali::Toolkit::Button arg2 ;
84548   Dali::Toolkit::Button *argp2 ;
84549   bool result;
84550
84551   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
84552   argp2 = (Dali::Toolkit::Button *)jarg2;
84553   if (!argp2) {
84554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
84555     return 0;
84556   }
84557   arg2 = *argp2;
84558   {
84559     try {
84560       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
84561     } catch (std::out_of_range& e) {
84562       {
84563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84564       };
84565     } catch (std::exception& e) {
84566       {
84567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84568       };
84569     } catch (...) {
84570       {
84571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84572       };
84573     }
84574   }
84575   jresult = result;
84576   return jresult;
84577 }
84578
84579
84580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
84581   void * jresult ;
84582   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
84583
84584   {
84585     try {
84586       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
84587     } catch (std::out_of_range& e) {
84588       {
84589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84590       };
84591     } catch (std::exception& e) {
84592       {
84593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84594       };
84595     } catch (...) {
84596       {
84597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84598       };
84599     }
84600   }
84601   jresult = (void *)result;
84602   return jresult;
84603 }
84604
84605
84606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
84607   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
84608
84609   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
84610   {
84611     try {
84612       delete arg1;
84613     } catch (std::out_of_range& e) {
84614       {
84615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84616       };
84617     } catch (std::exception& e) {
84618       {
84619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84620       };
84621     } catch (...) {
84622       {
84623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84624       };
84625     }
84626   }
84627 }
84628
84629
84630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
84631   unsigned int jresult ;
84632   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
84633   bool result;
84634
84635   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
84636   {
84637     try {
84638       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
84639     } catch (std::out_of_range& e) {
84640       {
84641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84642       };
84643     } catch (std::exception& e) {
84644       {
84645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84646       };
84647     } catch (...) {
84648       {
84649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84650       };
84651     }
84652   }
84653   jresult = result;
84654   return jresult;
84655 }
84656
84657
84658 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
84659   unsigned long jresult ;
84660   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
84661   std::size_t result;
84662
84663   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
84664   {
84665     try {
84666       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
84667     } catch (std::out_of_range& e) {
84668       {
84669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84670       };
84671     } catch (std::exception& e) {
84672       {
84673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84674       };
84675     } catch (...) {
84676       {
84677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84678       };
84679     }
84680   }
84681   jresult = (unsigned long)result;
84682   return jresult;
84683 }
84684
84685
84686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
84687   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
84688   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
84689
84690   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
84691   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
84692   {
84693     try {
84694       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
84695     } catch (std::out_of_range& e) {
84696       {
84697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84698       };
84699     } catch (std::exception& e) {
84700       {
84701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84702       };
84703     } catch (...) {
84704       {
84705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84706       };
84707     }
84708   }
84709 }
84710
84711
84712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
84713   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
84714   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
84715
84716   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
84717   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
84718   {
84719     try {
84720       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
84721     } catch (std::out_of_range& e) {
84722       {
84723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84724       };
84725     } catch (std::exception& e) {
84726       {
84727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84728       };
84729     } catch (...) {
84730       {
84731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84732       };
84733     }
84734   }
84735 }
84736
84737
84738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
84739   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
84740   Dali::Toolkit::GaussianBlurView arg2 ;
84741   Dali::Toolkit::GaussianBlurView *argp2 ;
84742
84743   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
84744   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
84745   if (!argp2) {
84746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
84747     return ;
84748   }
84749   arg2 = *argp2;
84750   {
84751     try {
84752       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
84753     } catch (std::out_of_range& e) {
84754       {
84755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84756       };
84757     } catch (std::exception& e) {
84758       {
84759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84760       };
84761     } catch (...) {
84762       {
84763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84764       };
84765     }
84766   }
84767 }
84768
84769
84770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
84771   void * jresult ;
84772   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
84773
84774   {
84775     try {
84776       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
84777     } catch (std::out_of_range& e) {
84778       {
84779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84780       };
84781     } catch (std::exception& e) {
84782       {
84783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84784       };
84785     } catch (...) {
84786       {
84787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84788       };
84789     }
84790   }
84791   jresult = (void *)result;
84792   return jresult;
84793 }
84794
84795
84796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
84797   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
84798
84799   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
84800   {
84801     try {
84802       delete arg1;
84803     } catch (std::out_of_range& e) {
84804       {
84805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84806       };
84807     } catch (std::exception& e) {
84808       {
84809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84810       };
84811     } catch (...) {
84812       {
84813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84814       };
84815     }
84816   }
84817 }
84818
84819
84820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
84821   unsigned int jresult ;
84822   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84823   bool result;
84824
84825   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84826   {
84827     try {
84828       result = (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 *)arg1);
84829     } catch (std::out_of_range& e) {
84830       {
84831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84832       };
84833     } catch (std::exception& e) {
84834       {
84835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84836       };
84837     } catch (...) {
84838       {
84839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84840       };
84841     }
84842   }
84843   jresult = result;
84844   return jresult;
84845 }
84846
84847
84848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
84849   unsigned long jresult ;
84850   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84851   std::size_t result;
84852
84853   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84854   {
84855     try {
84856       result = 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 *)arg1);
84857     } catch (std::out_of_range& e) {
84858       {
84859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84860       };
84861     } catch (std::exception& e) {
84862       {
84863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84864       };
84865     } catch (...) {
84866       {
84867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84868       };
84869     }
84870   }
84871   jresult = (unsigned long)result;
84872   return jresult;
84873 }
84874
84875
84876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
84877   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84878   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
84879
84880   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84881   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
84882   {
84883     try {
84884       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
84885     } catch (std::out_of_range& e) {
84886       {
84887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84888       };
84889     } catch (std::exception& e) {
84890       {
84891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84892       };
84893     } catch (...) {
84894       {
84895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84896       };
84897     }
84898   }
84899 }
84900
84901
84902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
84903   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84904   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
84905
84906   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84907   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
84908   {
84909     try {
84910       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
84911     } catch (std::out_of_range& e) {
84912       {
84913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84914       };
84915     } catch (std::exception& e) {
84916       {
84917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84918       };
84919     } catch (...) {
84920       {
84921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84922       };
84923     }
84924   }
84925 }
84926
84927
84928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
84929   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84930   Dali::Toolkit::PageTurnView arg2 ;
84931   unsigned int arg3 ;
84932   bool arg4 ;
84933   Dali::Toolkit::PageTurnView *argp2 ;
84934
84935   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84936   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84937   if (!argp2) {
84938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84939     return ;
84940   }
84941   arg2 = *argp2;
84942   arg3 = (unsigned int)jarg3;
84943   arg4 = jarg4 ? true : false;
84944   {
84945     try {
84946       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84947     } catch (std::out_of_range& e) {
84948       {
84949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84950       };
84951     } catch (std::exception& e) {
84952       {
84953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84954       };
84955     } catch (...) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84958       };
84959     }
84960   }
84961 }
84962
84963
84964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
84965   void * jresult ;
84966   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
84967
84968   {
84969     try {
84970       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
84971     } catch (std::out_of_range& e) {
84972       {
84973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84974       };
84975     } catch (std::exception& e) {
84976       {
84977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84978       };
84979     } catch (...) {
84980       {
84981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84982       };
84983     }
84984   }
84985   jresult = (void *)result;
84986   return jresult;
84987 }
84988
84989
84990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
84991   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84992
84993   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84994   {
84995     try {
84996       delete arg1;
84997     } catch (std::out_of_range& e) {
84998       {
84999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85000       };
85001     } catch (std::exception& e) {
85002       {
85003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85004       };
85005     } catch (...) {
85006       {
85007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85008       };
85009     }
85010   }
85011 }
85012
85013
85014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
85015   unsigned int jresult ;
85016   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
85017   bool result;
85018
85019   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
85020   {
85021     try {
85022       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
85023     } catch (std::out_of_range& e) {
85024       {
85025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85026       };
85027     } catch (std::exception& e) {
85028       {
85029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85030       };
85031     } catch (...) {
85032       {
85033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85034       };
85035     }
85036   }
85037   jresult = result;
85038   return jresult;
85039 }
85040
85041
85042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
85043   unsigned long jresult ;
85044   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
85045   std::size_t result;
85046
85047   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
85048   {
85049     try {
85050       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
85051     } catch (std::out_of_range& e) {
85052       {
85053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85054       };
85055     } catch (std::exception& e) {
85056       {
85057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85058       };
85059     } catch (...) {
85060       {
85061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85062       };
85063     }
85064   }
85065   jresult = (unsigned long)result;
85066   return jresult;
85067 }
85068
85069
85070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
85071   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
85072   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
85073
85074   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
85075   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
85076   {
85077     try {
85078       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
85079     } catch (std::out_of_range& e) {
85080       {
85081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85082       };
85083     } catch (std::exception& e) {
85084       {
85085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85086       };
85087     } catch (...) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85090       };
85091     }
85092   }
85093 }
85094
85095
85096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
85097   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
85098   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
85099
85100   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
85101   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
85102   {
85103     try {
85104       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
85105     } catch (std::out_of_range& e) {
85106       {
85107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85108       };
85109     } catch (std::exception& e) {
85110       {
85111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85112       };
85113     } catch (...) {
85114       {
85115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85116       };
85117     }
85118   }
85119 }
85120
85121
85122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
85123   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
85124   Dali::Toolkit::PageTurnView arg2 ;
85125   Dali::Toolkit::PageTurnView *argp2 ;
85126
85127   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
85128   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
85129   if (!argp2) {
85130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
85131     return ;
85132   }
85133   arg2 = *argp2;
85134   {
85135     try {
85136       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
85137     } catch (std::out_of_range& e) {
85138       {
85139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85140       };
85141     } catch (std::exception& e) {
85142       {
85143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85144       };
85145     } catch (...) {
85146       {
85147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85148       };
85149     }
85150   }
85151 }
85152
85153
85154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
85155   void * jresult ;
85156   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
85157
85158   {
85159     try {
85160       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
85161     } catch (std::out_of_range& e) {
85162       {
85163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85164       };
85165     } catch (std::exception& e) {
85166       {
85167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85168       };
85169     } catch (...) {
85170       {
85171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85172       };
85173     }
85174   }
85175   jresult = (void *)result;
85176   return jresult;
85177 }
85178
85179
85180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
85181   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
85182
85183   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
85184   {
85185     try {
85186       delete arg1;
85187     } catch (std::out_of_range& e) {
85188       {
85189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85190       };
85191     } catch (std::exception& e) {
85192       {
85193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85194       };
85195     } catch (...) {
85196       {
85197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85198       };
85199     }
85200   }
85201 }
85202
85203
85204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
85205   unsigned int jresult ;
85206   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
85207   bool result;
85208
85209   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
85210   {
85211     try {
85212       result = (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 *)arg1);
85213     } catch (std::out_of_range& e) {
85214       {
85215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85216       };
85217     } catch (std::exception& e) {
85218       {
85219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85220       };
85221     } catch (...) {
85222       {
85223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85224       };
85225     }
85226   }
85227   jresult = result;
85228   return jresult;
85229 }
85230
85231
85232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
85233   unsigned long jresult ;
85234   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
85235   std::size_t result;
85236
85237   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
85238   {
85239     try {
85240       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *)arg1);
85241     } catch (std::out_of_range& e) {
85242       {
85243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85244       };
85245     } catch (std::exception& e) {
85246       {
85247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85248       };
85249     } catch (...) {
85250       {
85251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85252       };
85253     }
85254   }
85255   jresult = (unsigned long)result;
85256   return jresult;
85257 }
85258
85259
85260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
85261   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
85262   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
85263
85264   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
85265   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
85266   {
85267     try {
85268       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
85269     } catch (std::out_of_range& e) {
85270       {
85271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85272       };
85273     } catch (std::exception& e) {
85274       {
85275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85276       };
85277     } catch (...) {
85278       {
85279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85280       };
85281     }
85282   }
85283 }
85284
85285
85286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
85287   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
85288   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
85289
85290   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
85291   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
85292   {
85293     try {
85294       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
85295     } catch (std::out_of_range& e) {
85296       {
85297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85298       };
85299     } catch (std::exception& e) {
85300       {
85301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85302       };
85303     } catch (...) {
85304       {
85305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85306       };
85307     }
85308   }
85309 }
85310
85311
85312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
85313   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
85314   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
85315
85316   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
85317   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
85318   if (!arg2) {
85319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
85320     return ;
85321   }
85322   {
85323     try {
85324       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
85325     } catch (std::out_of_range& e) {
85326       {
85327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85328       };
85329     } catch (std::exception& e) {
85330       {
85331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85332       };
85333     } catch (...) {
85334       {
85335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85336       };
85337     }
85338   }
85339 }
85340
85341
85342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
85343   void * jresult ;
85344   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
85345
85346   {
85347     try {
85348       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
85349     } catch (std::out_of_range& e) {
85350       {
85351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85352       };
85353     } catch (std::exception& e) {
85354       {
85355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85356       };
85357     } catch (...) {
85358       {
85359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85360       };
85361     }
85362   }
85363   jresult = (void *)result;
85364   return jresult;
85365 }
85366
85367
85368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
85369   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
85370
85371   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
85372   {
85373     try {
85374       delete arg1;
85375     } catch (std::out_of_range& e) {
85376       {
85377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85378       };
85379     } catch (std::exception& e) {
85380       {
85381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85382       };
85383     } catch (...) {
85384       {
85385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85386       };
85387     }
85388   }
85389 }
85390
85391
85392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
85393   unsigned int jresult ;
85394   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
85395   bool result;
85396
85397   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
85398   {
85399     try {
85400       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
85401     } catch (std::out_of_range& e) {
85402       {
85403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85404       };
85405     } catch (std::exception& e) {
85406       {
85407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85408       };
85409     } catch (...) {
85410       {
85411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85412       };
85413     }
85414   }
85415   jresult = result;
85416   return jresult;
85417 }
85418
85419
85420 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
85421   unsigned long jresult ;
85422   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
85423   std::size_t result;
85424
85425   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
85426   {
85427     try {
85428       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
85429     } catch (std::out_of_range& e) {
85430       {
85431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85432       };
85433     } catch (std::exception& e) {
85434       {
85435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85436       };
85437     } catch (...) {
85438       {
85439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85440       };
85441     }
85442   }
85443   jresult = (unsigned long)result;
85444   return jresult;
85445 }
85446
85447
85448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
85449   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
85450   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
85451
85452   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
85453   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
85454   {
85455     try {
85456       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
85457     } catch (std::out_of_range& e) {
85458       {
85459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85460       };
85461     } catch (std::exception& e) {
85462       {
85463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85464       };
85465     } catch (...) {
85466       {
85467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85468       };
85469     }
85470   }
85471 }
85472
85473
85474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
85475   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
85476   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
85477
85478   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
85479   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
85480   {
85481     try {
85482       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
85483     } catch (std::out_of_range& e) {
85484       {
85485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85486       };
85487     } catch (std::exception& e) {
85488       {
85489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85490       };
85491     } catch (...) {
85492       {
85493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85494       };
85495     }
85496   }
85497 }
85498
85499
85500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
85501   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
85502   Dali::Vector2 *arg2 = 0 ;
85503
85504   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
85505   arg2 = (Dali::Vector2 *)jarg2;
85506   if (!arg2) {
85507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85508     return ;
85509   }
85510   {
85511     try {
85512       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
85513     } catch (std::out_of_range& e) {
85514       {
85515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85516       };
85517     } catch (std::exception& e) {
85518       {
85519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85520       };
85521     } catch (...) {
85522       {
85523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85524       };
85525     }
85526   }
85527 }
85528
85529
85530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
85531   void * jresult ;
85532   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
85533
85534   {
85535     try {
85536       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
85537     } catch (std::out_of_range& e) {
85538       {
85539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85540       };
85541     } catch (std::exception& e) {
85542       {
85543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85544       };
85545     } catch (...) {
85546       {
85547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85548       };
85549     }
85550   }
85551   jresult = (void *)result;
85552   return jresult;
85553 }
85554
85555
85556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
85557   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
85558
85559   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
85560   {
85561     try {
85562       delete arg1;
85563     } catch (std::out_of_range& e) {
85564       {
85565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85566       };
85567     } catch (std::exception& e) {
85568       {
85569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85570       };
85571     } catch (...) {
85572       {
85573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85574       };
85575     }
85576   }
85577 }
85578
85579
85580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
85581   unsigned int jresult ;
85582   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
85583   bool result;
85584
85585   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
85586   {
85587     try {
85588       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
85589     } catch (std::out_of_range& e) {
85590       {
85591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85592       };
85593     } catch (std::exception& e) {
85594       {
85595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85596       };
85597     } catch (...) {
85598       {
85599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85600       };
85601     }
85602   }
85603   jresult = result;
85604   return jresult;
85605 }
85606
85607
85608 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
85609   unsigned long jresult ;
85610   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
85611   std::size_t result;
85612
85613   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
85614   {
85615     try {
85616       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
85617     } catch (std::out_of_range& e) {
85618       {
85619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85620       };
85621     } catch (std::exception& e) {
85622       {
85623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85624       };
85625     } catch (...) {
85626       {
85627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85628       };
85629     }
85630   }
85631   jresult = (unsigned long)result;
85632   return jresult;
85633 }
85634
85635
85636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
85637   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
85638   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
85639
85640   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
85641   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
85642   {
85643     try {
85644       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
85645     } catch (std::out_of_range& e) {
85646       {
85647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85648       };
85649     } catch (std::exception& e) {
85650       {
85651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85652       };
85653     } catch (...) {
85654       {
85655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85656       };
85657     }
85658   }
85659 }
85660
85661
85662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
85663   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
85664   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
85665
85666   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
85667   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
85668   {
85669     try {
85670       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
85671     } catch (std::out_of_range& e) {
85672       {
85673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85674       };
85675     } catch (std::exception& e) {
85676       {
85677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85678       };
85679     } catch (...) {
85680       {
85681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85682       };
85683     }
85684   }
85685 }
85686
85687
85688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
85689   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
85690   Dali::Toolkit::TextEditor arg2 ;
85691   Dali::Toolkit::TextEditor *argp2 ;
85692
85693   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
85694   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
85695   if (!argp2) {
85696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
85697     return ;
85698   }
85699   arg2 = *argp2;
85700   {
85701     try {
85702       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
85703     } catch (std::out_of_range& e) {
85704       {
85705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85706       };
85707     } catch (std::exception& e) {
85708       {
85709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85710       };
85711     } catch (...) {
85712       {
85713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85714       };
85715     }
85716   }
85717 }
85718
85719
85720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
85721   void * jresult ;
85722   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
85723
85724   {
85725     try {
85726       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
85727     } catch (std::out_of_range& e) {
85728       {
85729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85730       };
85731     } catch (std::exception& e) {
85732       {
85733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85734       };
85735     } catch (...) {
85736       {
85737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85738       };
85739     }
85740   }
85741   jresult = (void *)result;
85742   return jresult;
85743 }
85744
85745
85746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
85747   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
85748
85749   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
85750   {
85751     try {
85752       delete arg1;
85753     } catch (std::out_of_range& e) {
85754       {
85755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85756       };
85757     } catch (std::exception& e) {
85758       {
85759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85760       };
85761     } catch (...) {
85762       {
85763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85764       };
85765     }
85766   }
85767 }
85768
85769
85770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
85771   unsigned int jresult ;
85772   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
85773   bool result;
85774
85775   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
85776   {
85777     try {
85778       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
85779     } catch (std::out_of_range& e) {
85780       {
85781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85782       };
85783     } catch (std::exception& e) {
85784       {
85785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85786       };
85787     } catch (...) {
85788       {
85789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85790       };
85791     }
85792   }
85793   jresult = result;
85794   return jresult;
85795 }
85796
85797
85798 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
85799   unsigned long jresult ;
85800   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
85801   std::size_t result;
85802
85803   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
85804   {
85805     try {
85806       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
85807     } catch (std::out_of_range& e) {
85808       {
85809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85810       };
85811     } catch (std::exception& e) {
85812       {
85813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85814       };
85815     } catch (...) {
85816       {
85817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85818       };
85819     }
85820   }
85821   jresult = (unsigned long)result;
85822   return jresult;
85823 }
85824
85825
85826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
85827   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
85828   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
85829
85830   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
85831   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
85832   {
85833     try {
85834       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
85835     } catch (std::out_of_range& e) {
85836       {
85837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85838       };
85839     } catch (std::exception& e) {
85840       {
85841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85842       };
85843     } catch (...) {
85844       {
85845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85846       };
85847     }
85848   }
85849 }
85850
85851
85852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
85853   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
85854   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
85855
85856   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
85857   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
85858   {
85859     try {
85860       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
85861     } catch (std::out_of_range& e) {
85862       {
85863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85864       };
85865     } catch (std::exception& e) {
85866       {
85867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85868       };
85869     } catch (...) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85872       };
85873     }
85874   }
85875 }
85876
85877
85878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
85879   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
85880   Dali::Toolkit::TextField arg2 ;
85881   Dali::Toolkit::TextField *argp2 ;
85882
85883   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
85884   argp2 = (Dali::Toolkit::TextField *)jarg2;
85885   if (!argp2) {
85886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
85887     return ;
85888   }
85889   arg2 = *argp2;
85890   {
85891     try {
85892       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
85893     } catch (std::out_of_range& e) {
85894       {
85895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85896       };
85897     } catch (std::exception& e) {
85898       {
85899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85900       };
85901     } catch (...) {
85902       {
85903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85904       };
85905     }
85906   }
85907 }
85908
85909
85910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
85911   void * jresult ;
85912   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
85913
85914   {
85915     try {
85916       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
85917     } catch (std::out_of_range& e) {
85918       {
85919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85920       };
85921     } catch (std::exception& e) {
85922       {
85923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85924       };
85925     } catch (...) {
85926       {
85927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85928       };
85929     }
85930   }
85931   jresult = (void *)result;
85932   return jresult;
85933 }
85934
85935
85936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
85937   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
85938
85939   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
85940   {
85941     try {
85942       delete arg1;
85943     } catch (std::out_of_range& e) {
85944       {
85945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85946       };
85947     } catch (std::exception& e) {
85948       {
85949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85950       };
85951     } catch (...) {
85952       {
85953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85954       };
85955     }
85956   }
85957 }
85958
85959
85960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeyEventSignal_Empty(void * jarg1) {
85961   unsigned int jresult ;
85962   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85963   bool result;
85964
85965   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85966   {
85967     try {
85968       result = (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 *)arg1);
85969     } catch (std::out_of_range& e) {
85970       {
85971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85972       };
85973     } catch (std::exception& e) {
85974       {
85975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85976       };
85977     } catch (...) {
85978       {
85979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85980       };
85981     }
85982   }
85983   jresult = result;
85984   return jresult;
85985 }
85986
85987
85988 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeyEventSignal_GetConnectionCount(void * jarg1) {
85989   unsigned long jresult ;
85990   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85991   std::size_t result;
85992
85993   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85994   {
85995     try {
85996       result = 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 *)arg1);
85997     } catch (std::out_of_range& e) {
85998       {
85999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86000       };
86001     } catch (std::exception& e) {
86002       {
86003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86004       };
86005     } catch (...) {
86006       {
86007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86008       };
86009     }
86010   }
86011   jresult = (unsigned long)result;
86012   return jresult;
86013 }
86014
86015
86016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeyEventSignal_Connect(void * jarg1, void * jarg2) {
86017   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
86018   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
86019
86020   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
86021   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
86022   {
86023     try {
86024       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
86025     } catch (std::out_of_range& e) {
86026       {
86027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86028       };
86029     } catch (std::exception& e) {
86030       {
86031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86032       };
86033     } catch (...) {
86034       {
86035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86036       };
86037     }
86038   }
86039 }
86040
86041
86042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
86043   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
86044   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
86045
86046   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
86047   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
86048   {
86049     try {
86050       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
86051     } catch (std::out_of_range& e) {
86052       {
86053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86054       };
86055     } catch (std::exception& e) {
86056       {
86057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86058       };
86059     } catch (...) {
86060       {
86061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86062       };
86063     }
86064   }
86065 }
86066
86067
86068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeyEventSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
86069   unsigned int jresult ;
86070   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
86071   Dali::Toolkit::Control arg2 ;
86072   Dali::KeyEvent *arg3 = 0 ;
86073   Dali::Toolkit::Control *argp2 ;
86074   bool result;
86075
86076   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
86077   argp2 = (Dali::Toolkit::Control *)jarg2;
86078   if (!argp2) {
86079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86080     return 0;
86081   }
86082   arg2 = *argp2;
86083   arg3 = (Dali::KeyEvent *)jarg3;
86084   if (!arg3) {
86085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
86086     return 0;
86087   }
86088   {
86089     try {
86090       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::KeyEvent const &)*arg3);
86091     } catch (std::out_of_range& e) {
86092       {
86093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86094       };
86095     } catch (std::exception& e) {
86096       {
86097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86098       };
86099     } catch (...) {
86100       {
86101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86102       };
86103     }
86104   }
86105   jresult = result;
86106   return jresult;
86107 }
86108
86109
86110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeyEventSignal() {
86111   void * jresult ;
86112   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
86113
86114   {
86115     try {
86116       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
86117     } catch (std::out_of_range& e) {
86118       {
86119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86120       };
86121     } catch (std::exception& e) {
86122       {
86123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (...) {
86126       {
86127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86128       };
86129     }
86130   }
86131   jresult = (void *)result;
86132   return jresult;
86133 }
86134
86135
86136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeyEventSignal(void * jarg1) {
86137   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
86138
86139   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
86140   {
86141     try {
86142       delete arg1;
86143     } catch (std::out_of_range& e) {
86144       {
86145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86146       };
86147     } catch (std::exception& e) {
86148       {
86149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86150       };
86151     } catch (...) {
86152       {
86153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86154       };
86155     }
86156   }
86157 }
86158
86159
86160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
86161   unsigned int jresult ;
86162   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86163   bool result;
86164
86165   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86166   {
86167     try {
86168       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86169     } catch (std::out_of_range& e) {
86170       {
86171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86172       };
86173     } catch (std::exception& e) {
86174       {
86175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86176       };
86177     } catch (...) {
86178       {
86179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86180       };
86181     }
86182   }
86183   jresult = result;
86184   return jresult;
86185 }
86186
86187
86188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
86189   unsigned long jresult ;
86190   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86191   std::size_t result;
86192
86193   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86194   {
86195     try {
86196       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86197     } catch (std::out_of_range& e) {
86198       {
86199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86200       };
86201     } catch (std::exception& e) {
86202       {
86203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86204       };
86205     } catch (...) {
86206       {
86207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86208       };
86209     }
86210   }
86211   jresult = (unsigned long)result;
86212   return jresult;
86213 }
86214
86215
86216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
86217   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86218   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86219
86220   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86221   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86222   {
86223     try {
86224       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
86225     } catch (std::out_of_range& e) {
86226       {
86227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86228       };
86229     } catch (std::exception& e) {
86230       {
86231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86232       };
86233     } catch (...) {
86234       {
86235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86236       };
86237     }
86238   }
86239 }
86240
86241
86242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
86243   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86244   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86245
86246   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86247   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86248   {
86249     try {
86250       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
86251     } catch (std::out_of_range& e) {
86252       {
86253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86254       };
86255     } catch (std::exception& e) {
86256       {
86257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86258       };
86259     } catch (...) {
86260       {
86261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86262       };
86263     }
86264   }
86265 }
86266
86267
86268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
86269   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86270   Dali::Toolkit::Control arg2 ;
86271   Dali::Toolkit::Control *argp2 ;
86272
86273   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86274   argp2 = (Dali::Toolkit::Control *)jarg2;
86275   if (!argp2) {
86276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86277     return ;
86278   }
86279   arg2 = *argp2;
86280   {
86281     try {
86282       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
86283     } catch (std::out_of_range& e) {
86284       {
86285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86286       };
86287     } catch (std::exception& e) {
86288       {
86289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86290       };
86291     } catch (...) {
86292       {
86293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86294       };
86295     }
86296   }
86297 }
86298
86299
86300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
86301   void * jresult ;
86302   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
86303
86304   {
86305     try {
86306       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
86307     } catch (std::out_of_range& e) {
86308       {
86309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86310       };
86311     } catch (std::exception& e) {
86312       {
86313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86314       };
86315     } catch (...) {
86316       {
86317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86318       };
86319     }
86320   }
86321   jresult = (void *)result;
86322   return jresult;
86323 }
86324
86325
86326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
86327   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86328
86329   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86330   {
86331     try {
86332       delete arg1;
86333     } catch (std::out_of_range& e) {
86334       {
86335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86336       };
86337     } catch (std::exception& e) {
86338       {
86339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86340       };
86341     } catch (...) {
86342       {
86343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86344       };
86345     }
86346   }
86347 }
86348
86349
86350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
86351   unsigned int jresult ;
86352   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
86353   bool result;
86354
86355   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
86356   {
86357     try {
86358       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
86359     } catch (std::out_of_range& e) {
86360       {
86361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86362       };
86363     } catch (std::exception& e) {
86364       {
86365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86366       };
86367     } catch (...) {
86368       {
86369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86370       };
86371     }
86372   }
86373   jresult = result;
86374   return jresult;
86375 }
86376
86377
86378 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
86379   unsigned long jresult ;
86380   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
86381   std::size_t result;
86382
86383   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
86384   {
86385     try {
86386       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
86387     } catch (std::out_of_range& e) {
86388       {
86389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86390       };
86391     } catch (std::exception& e) {
86392       {
86393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86394       };
86395     } catch (...) {
86396       {
86397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86398       };
86399     }
86400   }
86401   jresult = (unsigned long)result;
86402   return jresult;
86403 }
86404
86405
86406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
86407   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
86408   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
86409
86410   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
86411   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
86412   {
86413     try {
86414       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
86415     } catch (std::out_of_range& e) {
86416       {
86417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86418       };
86419     } catch (std::exception& e) {
86420       {
86421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86422       };
86423     } catch (...) {
86424       {
86425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86426       };
86427     }
86428   }
86429 }
86430
86431
86432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
86433   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
86434   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
86435
86436   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
86437   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
86438   {
86439     try {
86440       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
86441     } catch (std::out_of_range& e) {
86442       {
86443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86444       };
86445     } catch (std::exception& e) {
86446       {
86447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86448       };
86449     } catch (...) {
86450       {
86451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86452       };
86453     }
86454   }
86455 }
86456
86457
86458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
86459   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
86460   Dali::Toolkit::VideoView *arg2 = 0 ;
86461
86462   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
86463   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86464   if (!arg2) {
86465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
86466     return ;
86467   }
86468   {
86469     try {
86470       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
86471     } catch (std::out_of_range& e) {
86472       {
86473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86474       };
86475     } catch (std::exception& e) {
86476       {
86477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86478       };
86479     } catch (...) {
86480       {
86481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86482       };
86483     }
86484   }
86485 }
86486
86487
86488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
86489   void * jresult ;
86490   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
86491
86492   {
86493     try {
86494       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
86495     } catch (std::out_of_range& e) {
86496       {
86497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86498       };
86499     } catch (std::exception& e) {
86500       {
86501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86502       };
86503     } catch (...) {
86504       {
86505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86506       };
86507     }
86508   }
86509   jresult = (void *)result;
86510   return jresult;
86511 }
86512
86513
86514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
86515   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
86516
86517   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
86518   {
86519     try {
86520       delete arg1;
86521     } catch (std::out_of_range& e) {
86522       {
86523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86524       };
86525     } catch (std::exception& e) {
86526       {
86527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86528       };
86529     } catch (...) {
86530       {
86531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86532       };
86533     }
86534   }
86535 }
86536
86537
86538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
86539   unsigned int jresult ;
86540   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
86541   bool result;
86542
86543   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
86544   {
86545     try {
86546       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
86547     } catch (std::out_of_range& e) {
86548       {
86549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86550       };
86551     } catch (std::exception& e) {
86552       {
86553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86554       };
86555     } catch (...) {
86556       {
86557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86558       };
86559     }
86560   }
86561   jresult = result;
86562   return jresult;
86563 }
86564
86565
86566 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
86567   unsigned long jresult ;
86568   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
86569   std::size_t result;
86570
86571   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
86572   {
86573     try {
86574       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
86575     } catch (std::out_of_range& e) {
86576       {
86577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86578       };
86579     } catch (std::exception& e) {
86580       {
86581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86582       };
86583     } catch (...) {
86584       {
86585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86586       };
86587     }
86588   }
86589   jresult = (unsigned long)result;
86590   return jresult;
86591 }
86592
86593
86594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
86595   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
86596   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
86597
86598   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
86599   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
86600   {
86601     try {
86602       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
86603     } catch (std::out_of_range& e) {
86604       {
86605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86606       };
86607     } catch (std::exception& e) {
86608       {
86609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86610       };
86611     } catch (...) {
86612       {
86613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86614       };
86615     }
86616   }
86617 }
86618
86619
86620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
86621   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
86622   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
86623
86624   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
86625   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
86626   {
86627     try {
86628       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
86629     } catch (std::out_of_range& e) {
86630       {
86631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86632       };
86633     } catch (std::exception& e) {
86634       {
86635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86636       };
86637     } catch (...) {
86638       {
86639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86640       };
86641     }
86642   }
86643 }
86644
86645
86646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
86647   unsigned int jresult ;
86648   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
86649   Dali::Toolkit::Slider arg2 ;
86650   float arg3 ;
86651   Dali::Toolkit::Slider *argp2 ;
86652   bool result;
86653
86654   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
86655   argp2 = (Dali::Toolkit::Slider *)jarg2;
86656   if (!argp2) {
86657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
86658     return 0;
86659   }
86660   arg2 = *argp2;
86661   arg3 = (float)jarg3;
86662   {
86663     try {
86664       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
86665     } catch (std::out_of_range& e) {
86666       {
86667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86668       };
86669     } catch (std::exception& e) {
86670       {
86671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86672       };
86673     } catch (...) {
86674       {
86675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86676       };
86677     }
86678   }
86679   jresult = result;
86680   return jresult;
86681 }
86682
86683
86684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
86685   void * jresult ;
86686   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
86687
86688   {
86689     try {
86690       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
86691     } catch (std::out_of_range& e) {
86692       {
86693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86694       };
86695     } catch (std::exception& e) {
86696       {
86697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86698       };
86699     } catch (...) {
86700       {
86701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86702       };
86703     }
86704   }
86705   jresult = (void *)result;
86706   return jresult;
86707 }
86708
86709
86710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
86711   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
86712
86713   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
86714   {
86715     try {
86716       delete arg1;
86717     } catch (std::out_of_range& e) {
86718       {
86719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86720       };
86721     } catch (std::exception& e) {
86722       {
86723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86724       };
86725     } catch (...) {
86726       {
86727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86728       };
86729     }
86730   }
86731 }
86732
86733
86734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
86735   unsigned int jresult ;
86736   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
86737   bool result;
86738
86739   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
86740   {
86741     try {
86742       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
86743     } catch (std::out_of_range& e) {
86744       {
86745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86746       };
86747     } catch (std::exception& e) {
86748       {
86749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86750       };
86751     } catch (...) {
86752       {
86753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86754       };
86755     }
86756   }
86757   jresult = result;
86758   return jresult;
86759 }
86760
86761
86762 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
86763   unsigned long jresult ;
86764   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
86765   std::size_t result;
86766
86767   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
86768   {
86769     try {
86770       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
86771     } catch (std::out_of_range& e) {
86772       {
86773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86774       };
86775     } catch (std::exception& e) {
86776       {
86777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86778       };
86779     } catch (...) {
86780       {
86781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86782       };
86783     }
86784   }
86785   jresult = (unsigned long)result;
86786   return jresult;
86787 }
86788
86789
86790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
86791   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
86792   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
86793
86794   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
86795   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
86796   {
86797     try {
86798       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
86799     } catch (std::out_of_range& e) {
86800       {
86801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86802       };
86803     } catch (std::exception& e) {
86804       {
86805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86806       };
86807     } catch (...) {
86808       {
86809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86810       };
86811     }
86812   }
86813 }
86814
86815
86816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
86817   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
86818   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
86819
86820   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
86821   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
86822   {
86823     try {
86824       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
86825     } catch (std::out_of_range& e) {
86826       {
86827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86828       };
86829     } catch (std::exception& e) {
86830       {
86831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86832       };
86833     } catch (...) {
86834       {
86835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86836       };
86837     }
86838   }
86839 }
86840
86841
86842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
86843   unsigned int jresult ;
86844   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
86845   Dali::Toolkit::Slider arg2 ;
86846   int arg3 ;
86847   Dali::Toolkit::Slider *argp2 ;
86848   bool result;
86849
86850   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
86851   argp2 = (Dali::Toolkit::Slider *)jarg2;
86852   if (!argp2) {
86853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
86854     return 0;
86855   }
86856   arg2 = *argp2;
86857   arg3 = (int)jarg3;
86858   {
86859     try {
86860       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
86861     } catch (std::out_of_range& e) {
86862       {
86863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86864       };
86865     } catch (std::exception& e) {
86866       {
86867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86868       };
86869     } catch (...) {
86870       {
86871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86872       };
86873     }
86874   }
86875   jresult = result;
86876   return jresult;
86877 }
86878
86879
86880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
86881   void * jresult ;
86882   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
86883
86884   {
86885     try {
86886       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
86887     } catch (std::out_of_range& e) {
86888       {
86889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86890       };
86891     } catch (std::exception& e) {
86892       {
86893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86894       };
86895     } catch (...) {
86896       {
86897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86898       };
86899     }
86900   }
86901   jresult = (void *)result;
86902   return jresult;
86903 }
86904
86905
86906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
86907   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
86908
86909   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
86910   {
86911     try {
86912       delete arg1;
86913     } catch (std::out_of_range& e) {
86914       {
86915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86916       };
86917     } catch (std::exception& e) {
86918       {
86919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86920       };
86921     } catch (...) {
86922       {
86923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86924       };
86925     }
86926   }
86927 }
86928
86929
86930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
86931   void * jresult ;
86932   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86933
86934   {
86935     try {
86936       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
86937     } catch (std::out_of_range& e) {
86938       {
86939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86940       };
86941     } catch (std::exception& e) {
86942       {
86943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86944       };
86945     } catch (...) {
86946       {
86947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86948       };
86949     }
86950   }
86951   jresult = (void *)result;
86952   return jresult;
86953 }
86954
86955
86956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
86957   void * jresult ;
86958   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
86959   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86960
86961   arg1 = (Dali::Toolkit::Ruler *)jarg1;
86962   {
86963     try {
86964       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
86965     } catch (std::out_of_range& e) {
86966       {
86967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86968       };
86969     } catch (std::exception& e) {
86970       {
86971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86972       };
86973     } catch (...) {
86974       {
86975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86976       };
86977     }
86978   }
86979   jresult = (void *)result;
86980   return jresult;
86981 }
86982
86983
86984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
86985   void * jresult ;
86986   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
86987   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86988
86989   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86990   if (!arg1) {
86991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
86992     return 0;
86993   }
86994   {
86995     try {
86996       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
86997     } catch (std::out_of_range& e) {
86998       {
86999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87000       };
87001     } catch (std::exception& e) {
87002       {
87003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87004       };
87005     } catch (...) {
87006       {
87007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87008       };
87009     }
87010   }
87011   jresult = (void *)result;
87012   return jresult;
87013 }
87014
87015
87016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
87017   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87018
87019   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87020   {
87021     try {
87022       delete arg1;
87023     } catch (std::out_of_range& e) {
87024       {
87025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87026       };
87027     } catch (std::exception& e) {
87028       {
87029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87030       };
87031     } catch (...) {
87032       {
87033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87034       };
87035     }
87036   }
87037 }
87038
87039
87040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
87041   void * jresult ;
87042   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87043   Dali::Toolkit::Ruler *result = 0 ;
87044
87045   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87046   {
87047     try {
87048       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
87049     } catch (std::out_of_range& e) {
87050       {
87051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87052       };
87053     } catch (std::exception& e) {
87054       {
87055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87056       };
87057     } catch (...) {
87058       {
87059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87060       };
87061     }
87062   }
87063   jresult = (void *)result;
87064   return jresult;
87065 }
87066
87067
87068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
87069   void * jresult ;
87070   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87071   Dali::Toolkit::Ruler *result = 0 ;
87072
87073   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87074   {
87075     try {
87076       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
87077     } catch (std::out_of_range& e) {
87078       {
87079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87080       };
87081     } catch (std::exception& e) {
87082       {
87083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87084       };
87085     } catch (...) {
87086       {
87087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87088       };
87089     }
87090   }
87091   jresult = (void *)result;
87092   return jresult;
87093 }
87094
87095
87096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
87097   void * jresult ;
87098   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87099   Dali::Toolkit::Ruler *result = 0 ;
87100
87101   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87102   {
87103     try {
87104       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
87105     } catch (std::out_of_range& e) {
87106       {
87107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87108       };
87109     } catch (std::exception& e) {
87110       {
87111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87112       };
87113     } catch (...) {
87114       {
87115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87116       };
87117     }
87118   }
87119   jresult = (void *)result;
87120   return jresult;
87121 }
87122
87123
87124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
87125   void * jresult ;
87126   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87127   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
87128   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
87129
87130   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87131   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
87132   if (!arg2) {
87133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
87134     return 0;
87135   }
87136   {
87137     try {
87138       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
87139     } catch (std::out_of_range& e) {
87140       {
87141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87142       };
87143     } catch (std::exception& e) {
87144       {
87145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87146       };
87147     } catch (...) {
87148       {
87149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87150       };
87151     }
87152   }
87153   jresult = (void *)result;
87154   return jresult;
87155 }
87156
87157
87158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
87159   void * jresult ;
87160   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87161   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
87162   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
87163
87164   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87165   arg2 = (Dali::Toolkit::Ruler *)jarg2;
87166   {
87167     try {
87168       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
87169     } catch (std::out_of_range& e) {
87170       {
87171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87172       };
87173     } catch (std::exception& e) {
87174       {
87175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87176       };
87177     } catch (...) {
87178       {
87179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87180       };
87181     }
87182   }
87183   jresult = (void *)result;
87184   return jresult;
87185 }
87186
87187
87188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
87189   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87190
87191   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87192   {
87193     try {
87194       (arg1)->Reset();
87195     } catch (std::out_of_range& e) {
87196       {
87197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87198       };
87199     } catch (std::exception& e) {
87200       {
87201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87202       };
87203     } catch (...) {
87204       {
87205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87206       };
87207     }
87208   }
87209 }
87210
87211
87212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
87213   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87214   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
87215
87216   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87217   arg2 = (Dali::Toolkit::Ruler *)jarg2;
87218   {
87219     try {
87220       (arg1)->Reset(arg2);
87221     } catch (std::out_of_range& e) {
87222       {
87223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87224       };
87225     } catch (std::exception& e) {
87226       {
87227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87228       };
87229     } catch (...) {
87230       {
87231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87232       };
87233     }
87234   }
87235 }
87236
87237
87238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
87239   void * jresult ;
87240   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87241   Dali::Toolkit::Ruler *result = 0 ;
87242
87243   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87244   {
87245     try {
87246       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
87247     } catch (std::out_of_range& e) {
87248       {
87249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87250       };
87251     } catch (std::exception& e) {
87252       {
87253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87254       };
87255     } catch (...) {
87256       {
87257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87258       };
87259     }
87260   }
87261   jresult = (void *)result;
87262   return jresult;
87263 }
87264
87265
87266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
87267   float jresult ;
87268   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87269   float arg2 ;
87270   float arg3 ;
87271   float result;
87272
87273   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87274   arg2 = (float)jarg2;
87275   arg3 = (float)jarg3;
87276   {
87277     try {
87278       result = (float)(*arg1)->Snap(arg2,arg3);
87279     } catch (std::out_of_range& e) {
87280       {
87281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87282       };
87283     } catch (std::exception& e) {
87284       {
87285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87286       };
87287     } catch (...) {
87288       {
87289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87290       };
87291     }
87292   }
87293   jresult = result;
87294   return jresult;
87295 }
87296
87297
87298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
87299   float jresult ;
87300   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87301   float arg2 ;
87302   float result;
87303
87304   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87305   arg2 = (float)jarg2;
87306   {
87307     try {
87308       result = (float)(*arg1)->Snap(arg2);
87309     } catch (std::out_of_range& e) {
87310       {
87311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87312       };
87313     } catch (std::exception& e) {
87314       {
87315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87316       };
87317     } catch (...) {
87318       {
87319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87320       };
87321     }
87322   }
87323   jresult = result;
87324   return jresult;
87325 }
87326
87327
87328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
87329   float jresult ;
87330   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87331   unsigned int arg2 ;
87332   unsigned int *arg3 = 0 ;
87333   bool arg4 ;
87334   float result;
87335
87336   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87337   arg2 = (unsigned int)jarg2;
87338   arg3 = (unsigned int *)jarg3;
87339   arg4 = jarg4 ? true : false;
87340   {
87341     try {
87342       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
87343     } catch (std::out_of_range& e) {
87344       {
87345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87346       };
87347     } catch (std::exception& e) {
87348       {
87349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87350       };
87351     } catch (...) {
87352       {
87353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87354       };
87355     }
87356   }
87357   jresult = result;
87358   return jresult;
87359 }
87360
87361
87362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
87363   unsigned int jresult ;
87364   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87365   float arg2 ;
87366   bool arg3 ;
87367   unsigned int result;
87368
87369   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87370   arg2 = (float)jarg2;
87371   arg3 = jarg3 ? true : false;
87372   {
87373     try {
87374       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
87375     } catch (std::out_of_range& e) {
87376       {
87377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87378       };
87379     } catch (std::exception& e) {
87380       {
87381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87382       };
87383     } catch (...) {
87384       {
87385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87386       };
87387     }
87388   }
87389   jresult = result;
87390   return jresult;
87391 }
87392
87393
87394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
87395   unsigned int jresult ;
87396   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87397   unsigned int result;
87398
87399   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87400   {
87401     try {
87402       result = (unsigned int)(*arg1)->GetTotalPages();
87403     } catch (std::out_of_range& e) {
87404       {
87405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87406       };
87407     } catch (std::exception& e) {
87408       {
87409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87410       };
87411     } catch (...) {
87412       {
87413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87414       };
87415     }
87416   }
87417   jresult = result;
87418   return jresult;
87419 }
87420
87421
87422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
87423   int jresult ;
87424   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87425   Dali::Toolkit::Ruler::RulerType result;
87426
87427   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87428   {
87429     try {
87430       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
87431     } catch (std::out_of_range& e) {
87432       {
87433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87434       };
87435     } catch (std::exception& e) {
87436       {
87437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87438       };
87439     } catch (...) {
87440       {
87441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87442       };
87443     }
87444   }
87445   jresult = (int)result;
87446   return jresult;
87447 }
87448
87449
87450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
87451   unsigned int jresult ;
87452   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87453   bool result;
87454
87455   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87456   {
87457     try {
87458       result = (bool)(*arg1)->IsEnabled();
87459     } catch (std::out_of_range& e) {
87460       {
87461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87462       };
87463     } catch (std::exception& e) {
87464       {
87465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87466       };
87467     } catch (...) {
87468       {
87469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87470       };
87471     }
87472   }
87473   jresult = result;
87474   return jresult;
87475 }
87476
87477
87478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
87479   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87480
87481   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87482   {
87483     try {
87484       (*arg1)->Enable();
87485     } catch (std::out_of_range& e) {
87486       {
87487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87488       };
87489     } catch (std::exception& e) {
87490       {
87491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87492       };
87493     } catch (...) {
87494       {
87495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87496       };
87497     }
87498   }
87499 }
87500
87501
87502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
87503   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87504
87505   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87506   {
87507     try {
87508       (*arg1)->Disable();
87509     } catch (std::out_of_range& e) {
87510       {
87511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87512       };
87513     } catch (std::exception& e) {
87514       {
87515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87516       };
87517     } catch (...) {
87518       {
87519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87520       };
87521     }
87522   }
87523 }
87524
87525
87526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
87527   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87528   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
87529   Dali::Toolkit::RulerDomain *argp2 ;
87530
87531   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87532   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
87533   if (!argp2) {
87534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
87535     return ;
87536   }
87537   arg2 = *argp2;
87538   {
87539     try {
87540       (*arg1)->SetDomain(arg2);
87541     } catch (std::out_of_range& e) {
87542       {
87543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87544       };
87545     } catch (std::exception& e) {
87546       {
87547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87548       };
87549     } catch (...) {
87550       {
87551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87552       };
87553     }
87554   }
87555 }
87556
87557
87558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
87559   void * jresult ;
87560   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87561   Dali::Toolkit::RulerDomain *result = 0 ;
87562
87563   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87564   {
87565     try {
87566       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
87567     } catch (std::out_of_range& e) {
87568       {
87569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87570       };
87571     } catch (std::exception& e) {
87572       {
87573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87574       };
87575     } catch (...) {
87576       {
87577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87578       };
87579     }
87580   }
87581   jresult = (void *)result;
87582   return jresult;
87583 }
87584
87585
87586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
87587   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87588
87589   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87590   {
87591     try {
87592       (*arg1)->DisableDomain();
87593     } catch (std::out_of_range& e) {
87594       {
87595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87596       };
87597     } catch (std::exception& e) {
87598       {
87599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87600       };
87601     } catch (...) {
87602       {
87603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87604       };
87605     }
87606   }
87607 }
87608
87609
87610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
87611   float jresult ;
87612   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87613   float arg2 ;
87614   float arg3 ;
87615   float arg4 ;
87616   float result;
87617
87618   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87619   arg2 = (float)jarg2;
87620   arg3 = (float)jarg3;
87621   arg4 = (float)jarg4;
87622   {
87623     try {
87624       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
87625     } catch (std::out_of_range& e) {
87626       {
87627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87628       };
87629     } catch (std::exception& e) {
87630       {
87631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87632       };
87633     } catch (...) {
87634       {
87635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87636       };
87637     }
87638   }
87639   jresult = result;
87640   return jresult;
87641 }
87642
87643
87644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
87645   float jresult ;
87646   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87647   float arg2 ;
87648   float arg3 ;
87649   float result;
87650
87651   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87652   arg2 = (float)jarg2;
87653   arg3 = (float)jarg3;
87654   {
87655     try {
87656       result = (float)(*arg1)->Clamp(arg2,arg3);
87657     } catch (std::out_of_range& e) {
87658       {
87659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87660       };
87661     } catch (std::exception& e) {
87662       {
87663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87664       };
87665     } catch (...) {
87666       {
87667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87668       };
87669     }
87670   }
87671   jresult = result;
87672   return jresult;
87673 }
87674
87675
87676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
87677   float jresult ;
87678   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87679   float arg2 ;
87680   float result;
87681
87682   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87683   arg2 = (float)jarg2;
87684   {
87685     try {
87686       result = (float)(*arg1)->Clamp(arg2);
87687     } catch (std::out_of_range& e) {
87688       {
87689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87690       };
87691     } catch (std::exception& e) {
87692       {
87693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87694       };
87695     } catch (...) {
87696       {
87697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87698       };
87699     }
87700   }
87701   jresult = result;
87702   return jresult;
87703 }
87704
87705
87706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
87707   float jresult ;
87708   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87709   float arg2 ;
87710   float arg3 ;
87711   float arg4 ;
87712   Dali::Toolkit::ClampState *arg5 = 0 ;
87713   float result;
87714
87715   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87716   arg2 = (float)jarg2;
87717   arg3 = (float)jarg3;
87718   arg4 = (float)jarg4;
87719   arg5 = (Dali::Toolkit::ClampState *)jarg5;
87720   if (!arg5) {
87721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
87722     return 0;
87723   }
87724   {
87725     try {
87726       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
87727     } catch (std::out_of_range& e) {
87728       {
87729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87730       };
87731     } catch (std::exception& e) {
87732       {
87733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87734       };
87735     } catch (...) {
87736       {
87737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87738       };
87739     }
87740   }
87741   jresult = result;
87742   return jresult;
87743 }
87744
87745
87746 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
87747   float jresult ;
87748   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87749   float arg2 ;
87750   float arg3 ;
87751   float arg4 ;
87752   float arg5 ;
87753   float result;
87754
87755   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87756   arg2 = (float)jarg2;
87757   arg3 = (float)jarg3;
87758   arg4 = (float)jarg4;
87759   arg5 = (float)jarg5;
87760   {
87761     try {
87762       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
87763     } catch (std::out_of_range& e) {
87764       {
87765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87766       };
87767     } catch (std::exception& e) {
87768       {
87769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87770       };
87771     } catch (...) {
87772       {
87773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87774       };
87775     }
87776   }
87777   jresult = result;
87778   return jresult;
87779 }
87780
87781
87782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
87783   float jresult ;
87784   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87785   float arg2 ;
87786   float arg3 ;
87787   float arg4 ;
87788   float result;
87789
87790   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87791   arg2 = (float)jarg2;
87792   arg3 = (float)jarg3;
87793   arg4 = (float)jarg4;
87794   {
87795     try {
87796       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
87797     } catch (std::out_of_range& e) {
87798       {
87799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87800       };
87801     } catch (std::exception& e) {
87802       {
87803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87804       };
87805     } catch (...) {
87806       {
87807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87808       };
87809     }
87810   }
87811   jresult = result;
87812   return jresult;
87813 }
87814
87815
87816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
87817   float jresult ;
87818   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87819   float arg2 ;
87820   float arg3 ;
87821   float result;
87822
87823   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87824   arg2 = (float)jarg2;
87825   arg3 = (float)jarg3;
87826   {
87827     try {
87828       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
87829     } catch (std::out_of_range& e) {
87830       {
87831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87832       };
87833     } catch (std::exception& e) {
87834       {
87835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87836       };
87837     } catch (...) {
87838       {
87839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87840       };
87841     }
87842   }
87843   jresult = result;
87844   return jresult;
87845 }
87846
87847
87848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
87849   float jresult ;
87850   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87851   float arg2 ;
87852   float result;
87853
87854   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87855   arg2 = (float)jarg2;
87856   {
87857     try {
87858       result = (float)(*arg1)->SnapAndClamp(arg2);
87859     } catch (std::out_of_range& e) {
87860       {
87861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87862       };
87863     } catch (std::exception& e) {
87864       {
87865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87866       };
87867     } catch (...) {
87868       {
87869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87870       };
87871     }
87872   }
87873   jresult = result;
87874   return jresult;
87875 }
87876
87877
87878 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
87879   float jresult ;
87880   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87881   float arg2 ;
87882   float arg3 ;
87883   float arg4 ;
87884   float arg5 ;
87885   Dali::Toolkit::ClampState *arg6 = 0 ;
87886   float result;
87887
87888   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87889   arg2 = (float)jarg2;
87890   arg3 = (float)jarg3;
87891   arg4 = (float)jarg4;
87892   arg5 = (float)jarg5;
87893   arg6 = (Dali::Toolkit::ClampState *)jarg6;
87894   if (!arg6) {
87895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
87896     return 0;
87897   }
87898   {
87899     try {
87900       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
87901     } catch (std::out_of_range& e) {
87902       {
87903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87904       };
87905     } catch (std::exception& e) {
87906       {
87907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87908       };
87909     } catch (...) {
87910       {
87911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87912       };
87913     }
87914   }
87915   jresult = result;
87916   return jresult;
87917 }
87918
87919
87920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
87921   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87922
87923   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87924   {
87925     try {
87926       (*arg1)->Reference();
87927     } catch (std::out_of_range& e) {
87928       {
87929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87930       };
87931     } catch (std::exception& e) {
87932       {
87933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87934       };
87935     } catch (...) {
87936       {
87937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87938       };
87939     }
87940   }
87941 }
87942
87943
87944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
87945   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87946
87947   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87948   {
87949     try {
87950       (*arg1)->Unreference();
87951     } catch (std::out_of_range& e) {
87952       {
87953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87954       };
87955     } catch (std::exception& e) {
87956       {
87957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87958       };
87959     } catch (...) {
87960       {
87961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87962       };
87963     }
87964   }
87965 }
87966
87967
87968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
87969   int jresult ;
87970   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87971   int result;
87972
87973   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87974   {
87975     try {
87976       result = (int)(*arg1)->ReferenceCount();
87977     } catch (std::out_of_range& e) {
87978       {
87979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87980       };
87981     } catch (std::exception& e) {
87982       {
87983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87984       };
87985     } catch (...) {
87986       {
87987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87988       };
87989     }
87990   }
87991   jresult = result;
87992   return jresult;
87993 }
87994
87995
87996 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
87997     return (Dali::RefObject *)jarg1;
87998 }
87999
88000 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
88001     return (Dali::SignalObserver *)jarg1;
88002 }
88003
88004 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
88005     return (Dali::ConnectionTrackerInterface *)jarg1;
88006 }
88007
88008 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
88009     return (Dali::BaseHandle *)jarg1;
88010 }
88011
88012 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
88013     return (Dali::BaseHandle *)jarg1;
88014 }
88015
88016 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
88017     return (Dali::BaseHandle *)jarg1;
88018 }
88019
88020 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
88021     return (Dali::BaseHandle *)jarg1;
88022 }
88023
88024 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
88025     return (Dali::BaseHandle *)jarg1;
88026 }
88027
88028 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
88029     return (Dali::BaseHandle *)jarg1;
88030 }
88031
88032 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
88033     return (Dali::BaseHandle *)jarg1;
88034 }
88035
88036 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
88037     return (Dali::BaseHandle *)jarg1;
88038 }
88039
88040 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
88041     return (Dali::BaseHandle *)jarg1;
88042 }
88043
88044 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
88045     return (Dali::BaseHandle *)jarg1;
88046 }
88047
88048 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
88049     return (Dali::BaseHandle *)jarg1;
88050 }
88051
88052 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
88053     return (Dali::BaseHandle *)jarg1;
88054 }
88055
88056 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
88057     return (Dali::Handle *)jarg1;
88058 }
88059
88060 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
88061     return (Dali::Handle *)jarg1;
88062 }
88063
88064 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
88065     return (Dali::BaseHandle *)jarg1;
88066 }
88067
88068 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
88069     return (Dali::BaseHandle *)jarg1;
88070 }
88071
88072 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
88073     return (Dali::Handle *)jarg1;
88074 }
88075
88076 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TouchData_SWIGUpcast(Dali::TouchData *jarg1) {
88077     return (Dali::BaseHandle *)jarg1;
88078 }
88079
88080 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
88081     return (Dali::Handle *)jarg1;
88082 }
88083
88084 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
88085     return (Dali::GestureDetector *)jarg1;
88086 }
88087
88088 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
88089     return (Dali::Gesture *)jarg1;
88090 }
88091
88092 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
88093     return (Dali::Handle *)jarg1;
88094 }
88095
88096 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
88097     return (Dali::Actor *)jarg1;
88098 }
88099
88100 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
88101     return (Dali::BaseHandle *)jarg1;
88102 }
88103
88104 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
88105     return (Dali::RefObject *)jarg1;
88106 }
88107
88108 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
88109     return (Dali::Actor *)jarg1;
88110 }
88111
88112 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
88113     return (Dali::GestureDetector *)jarg1;
88114 }
88115
88116 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
88117     return (Dali::Gesture *)jarg1;
88118 }
88119
88120 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
88121     return (Dali::GestureDetector *)jarg1;
88122 }
88123
88124 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
88125     return (Dali::Gesture *)jarg1;
88126 }
88127
88128 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
88129     return (Dali::GestureDetector *)jarg1;
88130 }
88131
88132 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
88133     return (Dali::Gesture *)jarg1;
88134 }
88135
88136 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
88137     return (Dali::BaseHandle *)jarg1;
88138 }
88139
88140 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
88141     return (Dali::Handle *)jarg1;
88142 }
88143
88144 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
88145     return (Dali::BaseHandle *)jarg1;
88146 }
88147
88148 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
88149     return (Dali::Handle *)jarg1;
88150 }
88151
88152 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
88153     return (Dali::Handle *)jarg1;
88154 }
88155
88156 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
88157     return (Dali::Image *)jarg1;
88158 }
88159
88160 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
88161     return (Dali::Image *)jarg1;
88162 }
88163
88164 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
88165     return (Dali::Image *)jarg1;
88166 }
88167
88168 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
88169     return (Dali::RefObject *)jarg1;
88170 }
88171
88172 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
88173     return (Dali::Image *)jarg1;
88174 }
88175
88176 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
88177     return (Dali::Image *)jarg1;
88178 }
88179
88180 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
88181     return (Dali::ResourceImage *)jarg1;
88182 }
88183
88184 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
88185     return (Dali::Actor *)jarg1;
88186 }
88187
88188 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
88189     return (Dali::BaseHandle *)jarg1;
88190 }
88191
88192 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
88193     return (Dali::BaseHandle *)jarg1;
88194 }
88195
88196 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
88197     return (Dali::BaseHandle *)jarg1;
88198 }
88199
88200 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
88201     return (Dali::BaseHandle *)jarg1;
88202 }
88203
88204 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
88205     return (Dali::BaseHandle *)jarg1;
88206 }
88207
88208 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
88209     return (Dali::CustomActorImpl *)jarg1;
88210 }
88211
88212 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
88213     return (Dali::CustomActor *)jarg1;
88214 }
88215
88216 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
88217     return (Dali::Toolkit::Control *)jarg1;
88218 }
88219
88220 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
88221     return (Dali::Toolkit::Control *)jarg1;
88222 }
88223
88224 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
88225     return (Dali::Toolkit::Button *)jarg1;
88226 }
88227
88228 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
88229     return (Dali::Toolkit::Button *)jarg1;
88230 }
88231
88232 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
88233     return (Dali::Toolkit::Button *)jarg1;
88234 }
88235
88236 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
88237     return (Dali::Toolkit::Control *)jarg1;
88238 }
88239
88240 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
88241     return (Dali::Toolkit::Control *)jarg1;
88242 }
88243
88244 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
88245     return (Dali::Toolkit::Control *)jarg1;
88246 }
88247
88248 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
88249     return (Dali::Toolkit::Control *)jarg1;
88250 }
88251
88252 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
88253     return (Dali::Toolkit::Control *)jarg1;
88254 }
88255
88256 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
88257     return (Dali::RefObject *)jarg1;
88258 }
88259
88260 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
88261     return (Dali::Toolkit::Scrollable *)jarg1;
88262 }
88263
88264 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
88265     return (Dali::BaseHandle *)jarg1;
88266 }
88267
88268 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
88269     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
88270 }
88271
88272 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
88273     return (Dali::RefObject *)jarg1;
88274 }
88275
88276 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
88277     return (Dali::Toolkit::Ruler *)jarg1;
88278 }
88279
88280 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
88281     return (Dali::Toolkit::Ruler *)jarg1;
88282 }
88283
88284 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
88285     return (Dali::Toolkit::Scrollable *)jarg1;
88286 }
88287
88288 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
88289     return (Dali::Toolkit::Control *)jarg1;
88290 }
88291
88292 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
88293     return (Dali::Toolkit::Control *)jarg1;
88294 }
88295
88296 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
88297     return (Dali::Toolkit::Control *)jarg1;
88298 }
88299
88300 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
88301     return (Dali::Toolkit::Control *)jarg1;
88302 }
88303
88304 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
88305     return (Dali::BaseHandle *)jarg1;
88306 }
88307
88308 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
88309     return (Dali::BaseHandle *)jarg1;
88310 }
88311
88312 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
88313     return (Dali::Toolkit::Control *)jarg1;
88314 }
88315
88316 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
88317     return (Dali::Toolkit::Control *)jarg1;
88318 }
88319
88320 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
88321     return (Dali::Toolkit::Control *)jarg1;
88322 }
88323
88324 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
88325     return (Dali::Toolkit::Control *)jarg1;
88326 }
88327
88328 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
88329     return (Dali::Toolkit::Control *)jarg1;
88330 }
88331
88332 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
88333     return (Dali::Toolkit::Control *)jarg1;
88334 }
88335
88336 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
88337     return (Dali::Toolkit::PageTurnView *)jarg1;
88338 }
88339
88340 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
88341     return (Dali::Toolkit::PageTurnView *)jarg1;
88342 }
88343
88344 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
88345     return (Dali::BaseHandle *)jarg1;
88346 }
88347
88348 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
88349     return (Dali::BaseHandle *)jarg1;
88350 }
88351
88352 #ifdef __cplusplus
88353 }
88354 #endif
88355