dali-csharp-binder/src/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 #include <dali/devel-api/object/csharp-type-info.h>
 431 #include <dali/devel-api/object/csharp-type-registry.h>
 432
 433 #include <dali/public-api/adaptor-framework/timer.h>
 434 #include <dali/public-api/adaptor-framework/window.h>
 435 #include <dali/public-api/adaptor-framework/style-change.h>
 436 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 437 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 438
 439 #include <dali/devel-api/images/nine-patch-image.h>
 440
 441 #include <dali-toolkit/devel-api/builder/builder.h>
 442
 443 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 444
 445 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 446 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 447 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 448 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 449 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 452 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 453
 454 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 455 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 456 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 457
 458 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 459
 460 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 461
 462 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 463
 464 // add here SWIG version check
 465
 466 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 467 // disable Swig-dependent warnings
 468
 469 // 'identifier1' has C-linkage specified,
 470 // but returns UDT 'identifier2' which is incompatible with C
 471 #pragma warning(disable: 4190)
 472
 473 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 474 #pragma warning(disable: 4800)
 475
 476 // debug info too long etc etc
 477 #pragma warning(disable: 4786)
 478 #endif
 479
 480
 481 #include <stdexcept>
 482
 483
 484 #include <string>
 485
 486
 487 #include <vector>
 488 #include <algorithm>
 489 #include <stdexcept>
 490
 491
 492 #include <map>
 493 #include <algorithm>
 494 #include <stdexcept>
 495
 496
 497 #include <utility>
 498
 499
 500 typedef float floatp;
 501
 502 SWIGINTERN floatp *new_floatp(){
 503   return new float();
 504 }
 505 SWIGINTERN void delete_floatp(floatp *self){
 506   if (self) delete self;
 507 }
 508 SWIGINTERN void floatp_assign(floatp *self,float value){
 509   *self = value;
 510 }
 511 SWIGINTERN float floatp_value(floatp *self){
 512   return *self;
 513 }
 514 SWIGINTERN float *floatp_cast(floatp *self){
 515   return self;
 516 }
 517 SWIGINTERN floatp *floatp_frompointer(float *t){
 518   return (floatp *) t;
 519 }
 520
 521 typedef int intp;
 522
 523 SWIGINTERN intp *new_intp(){
 524   return new int();
 525 }
 526 SWIGINTERN void delete_intp(intp *self){
 527   if (self) delete self;
 528 }
 529 SWIGINTERN void intp_assign(intp *self,int value){
 530   *self = value;
 531 }
 532 SWIGINTERN int intp_value(intp *self){
 533   return *self;
 534 }
 535 SWIGINTERN int *intp_cast(intp *self){
 536   return self;
 537 }
 538 SWIGINTERN intp *intp_frompointer(int *t){
 539   return (intp *) t;
 540 }
 541
 542 typedef double doublep;
 543
 544 SWIGINTERN doublep *new_doublep(){
 545   return new double();
 546 }
 547 SWIGINTERN void delete_doublep(doublep *self){
 548   if (self) delete self;
 549 }
 550 SWIGINTERN void doublep_assign(doublep *self,double value){
 551   *self = value;
 552 }
 553 SWIGINTERN double doublep_value(doublep *self){
 554   return *self;
 555 }
 556 SWIGINTERN double *doublep_cast(doublep *self){
 557   return self;
 558 }
 559 SWIGINTERN doublep *doublep_frompointer(double *t){
 560   return (doublep *) t;
 561 }
 562
 563 typedef unsigned int uintp;
 564
 565 SWIGINTERN uintp *new_uintp(){
 566   return new unsigned int();
 567 }
 568 SWIGINTERN void delete_uintp(uintp *self){
 569   if (self) delete self;
 570 }
 571 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 572   *self = value;
 573 }
 574 SWIGINTERN unsigned int uintp_value(uintp *self){
 575   return *self;
 576 }
 577 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 578   return self;
 579 }
 580 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 581   return (uintp *) t;
 582 }
 583
 584 typedef unsigned short ushortp;
 585
 586 SWIGINTERN ushortp *new_ushortp(){
 587   return new unsigned short();
 588 }
 589 SWIGINTERN void delete_ushortp(ushortp *self){
 590   if (self) delete self;
 591 }
 592 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 593   *self = value;
 594 }
 595 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 596   return *self;
 597 }
 598 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 599   return self;
 600 }
 601 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 602   return (ushortp *) t;
 603 }
 604
 605 unsigned int int_to_uint(int x) {
 606    return (unsigned int) x;
 607 }
 608
 609
 610 using namespace Dali;
 611 using namespace Dali::Toolkit;
 612
 613 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 614
 615      // C++ code. DALi uses Handle <-> Body design pattern.
 616      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 617      // Handles in DALi can be converted into a boolean type
 618      // to check if the handle has a valid body attached to it.
 619      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 620      if( *self )
 621      {
 622        return true;
 623      }
 624      else
 625      {
 626        return false;
 627      }
 628     }
 629 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 630
 631      // C++ code. Check if two handles reference the same implemtion
 632      if( *self == rhs)
 633      {
 634        return true;
 635      }
 636      else
 637      {
 638        return false;
 639      }
 640     }
 641 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 642      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 643    }
 644 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 645      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 646    }
 647 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 648         std::vector< Dali::TouchPoint >* pv = 0;
 649         if (capacity >= 0) {
 650           pv = new std::vector< Dali::TouchPoint >();
 651           pv->reserve(capacity);
 652        } else {
 653           throw std::out_of_range("capacity");
 654        }
 655        return pv;
 656       }
 657 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 658         if (index>=0 && index<(int)self->size())
 659           return (*self)[index];
 660         else
 661           throw std::out_of_range("index");
 662       }
 663 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 664         if (index>=0 && index<(int)self->size())
 665           return (*self)[index];
 666         else
 667           throw std::out_of_range("index");
 668       }
 669 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 670         if (index>=0 && index<(int)self->size())
 671           (*self)[index] = val;
 672         else
 673           throw std::out_of_range("index");
 674       }
 675 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 676         self->insert(self->end(), values.begin(), values.end());
 677       }
 678 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 679         if (index < 0)
 680           throw std::out_of_range("index");
 681         if (count < 0)
 682           throw std::out_of_range("count");
 683         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 684           throw std::invalid_argument("invalid range");
 685         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 686       }
 687 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 688         if (index>=0 && index<(int)self->size()+1)
 689           self->insert(self->begin()+index, x);
 690         else
 691           throw std::out_of_range("index");
 692       }
 693 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 694         if (index>=0 && index<(int)self->size()+1)
 695           self->insert(self->begin()+index, values.begin(), values.end());
 696         else
 697           throw std::out_of_range("index");
 698       }
 699 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 700         if (index>=0 && index<(int)self->size())
 701           self->erase(self->begin() + index);
 702         else
 703           throw std::out_of_range("index");
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 706         if (index < 0)
 707           throw std::out_of_range("index");
 708         if (count < 0)
 709           throw std::out_of_range("count");
 710         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 711           throw std::invalid_argument("invalid range");
 712         self->erase(self->begin()+index, self->begin()+index+count);
 713       }
 714 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 715         if (count < 0)
 716           throw std::out_of_range("count");
 717         return new std::vector< Dali::TouchPoint >(count, value);
 718       }
 719 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 720         std::reverse(self->begin(), self->end());
 721       }
 722 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 723         if (index < 0)
 724           throw std::out_of_range("index");
 725         if (count < 0)
 726           throw std::out_of_range("count");
 727         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 728           throw std::invalid_argument("invalid range");
 729         std::reverse(self->begin()+index, self->begin()+index+count);
 730       }
 731 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 732         if (index < 0)
 733           throw std::out_of_range("index");
 734         if (index+values.size() > self->size())
 735           throw std::out_of_range("index");
 736         std::copy(values.begin(), values.end(), self->begin()+index);
 737       }
 738 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 739          return self->Empty();
 740       }
 741 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 742         return self->GetConnectionCount();
 743       }
 744 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 745           self->Connect( func );
 746       }
 747 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 748           self->Disconnect( func );
 749       }
 750 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 751           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 752 /*@SWIG@*/ self->Emit( arg );
 753       }
 754 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 755          return self->Empty();
 756       }
 757 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 758         return self->GetConnectionCount();
 759       }
 760 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 761           self->Connect( func );
 762       }
 763 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 764           self->Disconnect( func );
 765       }
 766 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 767           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 768 /*@SWIG@*/ self->Emit( arg );
 769       }
 770 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 771          return self->Empty();
 772       }
 773 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){
 774         return self->GetConnectionCount();
 775       }
 776 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 *)){
 777           self->Connect( func );
 778       }
 779 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 *)){
 780           self->Disconnect( func );
 781       }
 782 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){
 783           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 784 /*@SWIG@*/ self->Emit( arg );
 785       }
 786 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 787          return self->Empty();
 788       }
 789 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 790         return self->GetConnectionCount();
 791       }
 792 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 793           self->Connect( func );
 794       }
 795 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 796           self->Disconnect( func );
 797       }
 798 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 799           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 800 /*@SWIG@*/ self->Emit( arg );
 801       }
 802 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 803          return self->Empty();
 804       }
 805 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 806         return self->GetConnectionCount();
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 809           self->Connect( func );
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 812           self->Disconnect( func );
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 815           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 816 /*@SWIG@*/ self->Emit( arg );
 817       }
 818 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){
 819          return self->Empty();
 820       }
 821 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){
 822         return self->GetConnectionCount();
 823       }
 824 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 &)){
 825         self->Connect( func );
 826       }
 827 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 &)){
 828         self->Disconnect( func );
 829       }
 830 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){
 831         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 832 /*@SWIG@*/ self->Emit( arg1, arg2 );
 833       }
 834 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){
 835          return self->Empty();
 836       }
 837 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){
 838         return self->GetConnectionCount();
 839       }
 840 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 &)){
 841         self->Connect( func );
 842       }
 843 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 &)){
 844         self->Disconnect( func );
 845       }
 846 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){
 847         return self->Emit( arg1, arg2 );
 848       }
 849 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){
 850          return self->Empty();
 851       }
 852 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){
 853         return self->GetConnectionCount();
 854       }
 855 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 &)){
 856         self->Connect( func );
 857       }
 858 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 &)){
 859         self->Disconnect( func );
 860       }
 861 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){
 862         return self->Emit( arg1, arg2 );
 863       }
 864 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){
 865          return self->Empty();
 866       }
 867 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){
 868         return self->GetConnectionCount();
 869       }
 870 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 &)){
 871         self->Connect( func );
 872       }
 873 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 &)){
 874         self->Disconnect( func );
 875       }
 876 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){
 877         return self->Emit( arg1, arg2 );
 878       }
 879 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 880          return self->Empty();
 881       }
 882 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 883         return self->GetConnectionCount();
 884       }
 885 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 886           self->Connect( func );
 887       }
 888 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 889           self->Disconnect( func );
 890       }
 891 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 892           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 893 /*@SWIG@*/ self->Emit( arg );
 894       }
 895 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 896          return self->Empty();
 897       }
 898 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){
 899         return self->GetConnectionCount();
 900       }
 901 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 &)){
 902           self->Connect( func );
 903       }
 904 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 &)){
 905           self->Disconnect( func );
 906       }
 907 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){
 908           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 909 /*@SWIG@*/ self->Emit( arg );
 910       }
 911 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 912          return self->Empty();
 913       }
 914 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){
 915         return self->GetConnectionCount();
 916       }
 917 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 &)){
 918           self->Connect( func );
 919       }
 920 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 &)){
 921           self->Disconnect( func );
 922       }
 923 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){
 924           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 925 /*@SWIG@*/ self->Emit( arg );
 926       }
 927 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 928          return self->Empty();
 929       }
 930 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){
 931         return self->GetConnectionCount();
 932       }
 933 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 &)){
 934           self->Connect( func );
 935       }
 936 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 &)){
 937           self->Disconnect( func );
 938       }
 939 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){
 940           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 941 /*@SWIG@*/ self->Emit( arg );
 942       }
 943 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){
 944          return self->Empty();
 945       }
 946 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){
 947         return self->GetConnectionCount();
 948       }
 949 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 &)){
 950         self->Connect( func );
 951       }
 952 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 &)){
 953         self->Disconnect( func );
 954       }
 955 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){
 956         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 957 /*@SWIG@*/ self->Emit( arg1, arg2 );
 958       }
 959 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){
 960          return self->Empty();
 961       }
 962 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){
 963         return self->GetConnectionCount();
 964       }
 965 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 &)){
 966         self->Connect( func );
 967       }
 968 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 &)){
 969         self->Disconnect( func );
 970       }
 971 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){
 972         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 973 /*@SWIG@*/ self->Emit( arg1, arg2 );
 974       }
 975 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){
 976          return self->Empty();
 977       }
 978 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){
 979         return self->GetConnectionCount();
 980       }
 981 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 &)){
 982         self->Connect( func );
 983       }
 984 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 &)){
 985         self->Disconnect( func );
 986       }
 987 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){
 988         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 989 /*@SWIG@*/ self->Emit( arg1, arg2 );
 990       }
 991 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 992          return self->Empty();
 993       }
 994 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
 995         return self->GetConnectionCount();
 996       }
 997 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 998           self->Connect( func );
 999       }
1000 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1001           self->Disconnect( func );
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1004           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1005 /*@SWIG@*/ self->Emit( arg );
1006       }
1007 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1008          return self->Empty();
1009       }
1010 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1011         return self->GetConnectionCount();
1012       }
1013 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1014           self->Connect( func );
1015       }
1016 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1017           self->Disconnect( func );
1018       }
1019 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1020           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1021 /*@SWIG@*/ self->Emit( arg );
1022       }
1023
1024   // keep argcs and argv so they're always available to DALi
1025   int argC = 1;
1026   char **argV = NULL;
1027
1028 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1029          return self->Empty();
1030       }
1031 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1032         return self->GetConnectionCount();
1033       }
1034 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1035           self->Connect( func );
1036       }
1037 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1038           self->Disconnect( func );
1039       }
1040 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1041           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1042 /*@SWIG@*/ self->Emit( arg );
1043       }
1044 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1045          return self->Empty();
1046       }
1047 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){
1048         return self->GetConnectionCount();
1049       }
1050 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 *)){
1051         self->Connect( func );
1052       }
1053 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 *)){
1054         self->Disconnect( func );
1055       }
1056 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){
1057         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1058 /*@SWIG@*/ self->Emit( arg1, arg2 );
1059       }
1060 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1061         std::vector< unsigned int >* pv = 0;
1062         if (capacity >= 0) {
1063           pv = new std::vector< unsigned int >();
1064           pv->reserve(capacity);
1065        } else {
1066           throw std::out_of_range("capacity");
1067        }
1068        return pv;
1069       }
1070 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1071         if (index>=0 && index<(int)self->size())
1072           return (*self)[index];
1073         else
1074           throw std::out_of_range("index");
1075       }
1076 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1077         if (index>=0 && index<(int)self->size())
1078           return (*self)[index];
1079         else
1080           throw std::out_of_range("index");
1081       }
1082 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1083         if (index>=0 && index<(int)self->size())
1084           (*self)[index] = val;
1085         else
1086           throw std::out_of_range("index");
1087       }
1088 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1089         self->insert(self->end(), values.begin(), values.end());
1090       }
1091 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1092         if (index < 0)
1093           throw std::out_of_range("index");
1094         if (count < 0)
1095           throw std::out_of_range("count");
1096         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1097           throw std::invalid_argument("invalid range");
1098         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1099       }
1100 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1101         if (index>=0 && index<(int)self->size()+1)
1102           self->insert(self->begin()+index, x);
1103         else
1104           throw std::out_of_range("index");
1105       }
1106 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1107         if (index>=0 && index<(int)self->size()+1)
1108           self->insert(self->begin()+index, values.begin(), values.end());
1109         else
1110           throw std::out_of_range("index");
1111       }
1112 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1113         if (index>=0 && index<(int)self->size())
1114           self->erase(self->begin() + index);
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1119         if (index < 0)
1120           throw std::out_of_range("index");
1121         if (count < 0)
1122           throw std::out_of_range("count");
1123         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1124           throw std::invalid_argument("invalid range");
1125         self->erase(self->begin()+index, self->begin()+index+count);
1126       }
1127 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1128         if (count < 0)
1129           throw std::out_of_range("count");
1130         return new std::vector< unsigned int >(count, value);
1131       }
1132 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1133         std::reverse(self->begin(), self->end());
1134       }
1135 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1136         if (index < 0)
1137           throw std::out_of_range("index");
1138         if (count < 0)
1139           throw std::out_of_range("count");
1140         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1141           throw std::invalid_argument("invalid range");
1142         std::reverse(self->begin()+index, self->begin()+index+count);
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1145         if (index < 0)
1146           throw std::out_of_range("index");
1147         if (index+values.size() > self->size())
1148           throw std::out_of_range("index");
1149         std::copy(values.begin(), values.end(), self->begin()+index);
1150       }
1151 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1152         return std::find(self->begin(), self->end(), value) != self->end();
1153       }
1154 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1155         int index = -1;
1156         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1157         if (it != self->end())
1158           index = (int)(it - self->begin());
1159         return index;
1160       }
1161 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1162         int index = -1;
1163         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1164         if (rit != self->rend())
1165           index = (int)(self->rend() - 1 - rit);
1166         return index;
1167       }
1168 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1169         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1170         if (it != self->end()) {
1171           self->erase(it);
1172           return true;
1173         }
1174         return false;
1175       }
1176 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){
1177         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1178         if (capacity >= 0) {
1179           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1180           pv->reserve(capacity);
1181        } else {
1182           throw std::out_of_range("capacity");
1183        }
1184        return pv;
1185       }
1186 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){
1187         if (index>=0 && index<(int)self->size())
1188           return (*self)[index];
1189         else
1190           throw std::out_of_range("index");
1191       }
1192 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){
1193         if (index>=0 && index<(int)self->size())
1194           return (*self)[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__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1199         if (index>=0 && index<(int)self->size())
1200           (*self)[index] = val;
1201         else
1202           throw std::out_of_range("index");
1203       }
1204 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){
1205         self->insert(self->end(), values.begin(), values.end());
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__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1208         if (index < 0)
1209           throw std::out_of_range("index");
1210         if (count < 0)
1211           throw std::out_of_range("count");
1212         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1213           throw std::invalid_argument("invalid range");
1214         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1215       }
1216 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){
1217         if (index>=0 && index<(int)self->size()+1)
1218           self->insert(self->begin()+index, x);
1219         else
1220           throw std::out_of_range("index");
1221       }
1222 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){
1223         if (index>=0 && index<(int)self->size()+1)
1224           self->insert(self->begin()+index, values.begin(), values.end());
1225         else
1226           throw std::out_of_range("index");
1227       }
1228 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){
1229         if (index>=0 && index<(int)self->size())
1230           self->erase(self->begin() + index);
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 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){
1235         if (index < 0)
1236           throw std::out_of_range("index");
1237         if (count < 0)
1238           throw std::out_of_range("count");
1239         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1240           throw std::invalid_argument("invalid range");
1241         self->erase(self->begin()+index, self->begin()+index+count);
1242       }
1243 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){
1244         if (count < 0)
1245           throw std::out_of_range("count");
1246         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1247       }
1248 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){
1249         std::reverse(self->begin(), self->end());
1250       }
1251 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){
1252         if (index < 0)
1253           throw std::out_of_range("index");
1254         if (count < 0)
1255           throw std::out_of_range("count");
1256         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1257           throw std::invalid_argument("invalid range");
1258         std::reverse(self->begin()+index, self->begin()+index+count);
1259       }
1260 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){
1261         if (index < 0)
1262           throw std::out_of_range("index");
1263         if (index+values.size() > self->size())
1264           throw std::out_of_range("index");
1265         std::copy(values.begin(), values.end(), self->begin()+index);
1266       }
1267 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1268         std::vector< Dali::Actor >* pv = 0;
1269         if (capacity >= 0) {
1270           pv = new std::vector< Dali::Actor >();
1271           pv->reserve(capacity);
1272        } else {
1273           throw std::out_of_range("capacity");
1274        }
1275        return pv;
1276       }
1277 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1278         if (index>=0 && index<(int)self->size())
1279           return (*self)[index];
1280         else
1281           throw std::out_of_range("index");
1282       }
1283 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1284         if (index>=0 && index<(int)self->size())
1285           return (*self)[index];
1286         else
1287           throw std::out_of_range("index");
1288       }
1289 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1290         if (index>=0 && index<(int)self->size())
1291           (*self)[index] = val;
1292         else
1293           throw std::out_of_range("index");
1294       }
1295 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1296         self->insert(self->end(), values.begin(), values.end());
1297       }
1298 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1299         if (index < 0)
1300           throw std::out_of_range("index");
1301         if (count < 0)
1302           throw std::out_of_range("count");
1303         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1304           throw std::invalid_argument("invalid range");
1305         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1306       }
1307 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1308         if (index>=0 && index<(int)self->size()+1)
1309           self->insert(self->begin()+index, x);
1310         else
1311           throw std::out_of_range("index");
1312       }
1313 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1314         if (index>=0 && index<(int)self->size()+1)
1315           self->insert(self->begin()+index, values.begin(), values.end());
1316         else
1317           throw std::out_of_range("index");
1318       }
1319 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1320         if (index>=0 && index<(int)self->size())
1321           self->erase(self->begin() + index);
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1326         if (index < 0)
1327           throw std::out_of_range("index");
1328         if (count < 0)
1329           throw std::out_of_range("count");
1330         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1331           throw std::invalid_argument("invalid range");
1332         self->erase(self->begin()+index, self->begin()+index+count);
1333       }
1334 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1335         if (count < 0)
1336           throw std::out_of_range("count");
1337         return new std::vector< Dali::Actor >(count, value);
1338       }
1339 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1340         std::reverse(self->begin(), self->end());
1341       }
1342 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1343         if (index < 0)
1344           throw std::out_of_range("index");
1345         if (count < 0)
1346           throw std::out_of_range("count");
1347         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1348           throw std::invalid_argument("invalid range");
1349         std::reverse(self->begin()+index, self->begin()+index+count);
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1352         if (index < 0)
1353           throw std::out_of_range("index");
1354         if (index+values.size() > self->size())
1355           throw std::out_of_range("index");
1356         std::copy(values.begin(), values.end(), self->begin()+index);
1357       }
1358 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1359          return self->Empty();
1360       }
1361 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1362         return self->GetConnectionCount();
1363       }
1364 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 &)){
1365           self->Connect( func );
1366       }
1367 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 &)){
1368           self->Disconnect( func );
1369       }
1370 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){
1371           return self->Emit( arg );
1372       }
1373 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){
1374          return self->Empty();
1375       }
1376 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){
1377         return self->GetConnectionCount();
1378       }
1379 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)){
1380         self->Connect( func );
1381       }
1382 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)){
1383         self->Disconnect( func );
1384       }
1385 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){
1386         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1387 /*@SWIG@*/ self->Emit( arg1, arg2 );
1388       }
1389 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1390          return self->Empty();
1391       }
1392 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){
1393         return self->GetConnectionCount();
1394       }
1395 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)){
1396         self->Connect( func );
1397       }
1398 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)){
1399         self->Disconnect( func );
1400       }
1401 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){
1402         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1403 /*@SWIG@*/ self->Emit( arg1, arg2 );
1404       }
1405 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1406          return self->Empty();
1407       }
1408 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1409         return self->GetConnectionCount();
1410       }
1411 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)){
1412         self->Connect( func );
1413       }
1414 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)){
1415         self->Disconnect( func );
1416       }
1417 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){
1418         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1419 /*@SWIG@*/ self->Emit( arg1, arg2 );
1420       }
1421 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){
1422          return self->Empty();
1423       }
1424 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){
1425         return self->GetConnectionCount();
1426       }
1427 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)){
1428         self->Connect( func );
1429       }
1430 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)){
1431         self->Disconnect( func );
1432       }
1433 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){
1434         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1435 /*@SWIG@*/ self->Emit( arg1, arg2 );
1436       }
1437 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1438          return self->Empty();
1439       }
1440 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1441         return self->GetConnectionCount();
1442       }
1443 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)){
1444           self->Connect( func );
1445       }
1446 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)){
1447           self->Disconnect( func );
1448       }
1449 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1450           return self->Emit( arg );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1453          return self->Empty();
1454       }
1455 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1456         return self->GetConnectionCount();
1457       }
1458 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)){
1459           self->Connect( func );
1460       }
1461 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)){
1462           self->Disconnect( func );
1463       }
1464 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1465           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg );
1467       }
1468 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){
1469          return self->Empty();
1470       }
1471 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){
1472         return self->GetConnectionCount();
1473       }
1474 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)){
1475           return self->Connect( func );
1476       }
1477 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)){
1478           self->Disconnect( func );
1479       }
1480 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){
1481           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1485          return self->Empty();
1486       }
1487 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1488         return self->GetConnectionCount();
1489       }
1490 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)){
1491           self->Connect( func );
1492       }
1493 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)){
1494           self->Disconnect( func );
1495       }
1496 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1497           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1498 /*@SWIG@*/ self->Emit( arg );
1499       }
1500 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){
1501          return self->Empty();
1502       }
1503 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){
1504         return self->GetConnectionCount();
1505       }
1506 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 &)){
1507           self->Connect( func );
1508       }
1509 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 &)){
1510           self->Disconnect( func );
1511       }
1512 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){
1513           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1514 /*@SWIG@*/ self->Emit( arg );
1515       }
1516 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1517          return self->Empty();
1518       }
1519 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){
1520         return self->GetConnectionCount();
1521       }
1522 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 &)){
1523           self->Connect( func );
1524       }
1525 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 &)){
1526           self->Disconnect( func );
1527       }
1528 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){
1529           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1530 /*@SWIG@*/ self->Emit( arg );
1531       }
1532 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1533          return self->Empty();
1534       }
1535 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1536         return self->GetConnectionCount();
1537       }
1538 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)){
1539           self->Connect( func );
1540       }
1541 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)){
1542           self->Disconnect( func );
1543       }
1544 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1545           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1546 /*@SWIG@*/ self->Emit( arg );
1547       }
1548 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1549          return self->Empty();
1550       }
1551 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1552         return self->GetConnectionCount();
1553       }
1554 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)){
1555           self->Connect( func );
1556       }
1557 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)){
1558           self->Disconnect( func );
1559       }
1560 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1561           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1562 /*@SWIG@*/ self->Emit( arg );
1563       }
1564 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){
1565          return self->Empty();
1566       }
1567 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){
1568         return self->GetConnectionCount();
1569       }
1570 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 &)){
1571         self->Connect( func );
1572       }
1573 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 &)){
1574         self->Disconnect( func );
1575       }
1576 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){
1577         return self->Emit( arg1, arg2 );
1578       }
1579 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1580          return self->Empty();
1581       }
1582 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1583         return self->GetConnectionCount();
1584       }
1585 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)){
1586           self->Connect( func );
1587       }
1588 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)){
1589           self->Disconnect( func );
1590       }
1591 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1596          return self->Empty();
1597       }
1598 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1599         return self->GetConnectionCount();
1600       }
1601 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 &)){
1602           self->Connect( func );
1603       }
1604 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 &)){
1605           self->Disconnect( func );
1606       }
1607 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){
1608           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1609 /*@SWIG@*/ self->Emit( arg );
1610       }
1611 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1612          return self->Empty();
1613       }
1614 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){
1615         return self->GetConnectionCount();
1616       }
1617 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)){
1618         self->Connect( func );
1619       }
1620 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)){
1621         self->Disconnect( func );
1622       }
1623 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){
1624         return self->Emit( arg1, arg2 );
1625       }
1626 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1627          return self->Empty();
1628       }
1629 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){
1630         return self->GetConnectionCount();
1631       }
1632 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)){
1633         self->Connect( func );
1634       }
1635 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)){
1636         self->Disconnect( func );
1637       }
1638 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){
1639         return self->Emit( arg1, arg2 );
1640       }
1641
1642
1643 /* ---------------------------------------------------
1644  * C++ director class methods
1645  * --------------------------------------------------- */
1646
1647 #include "dali_wrap.h"
1648
1649 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1650   swig_init_callbacks();
1651 }
1652
1653 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1654
1655 }
1656
1657
1658 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1659   int jdepth  ;
1660
1661   if (!swig_callbackOnStageConnection) {
1662     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1663     return;
1664   } else {
1665     jdepth = depth;
1666     swig_callbackOnStageConnection(jdepth);
1667   }
1668 }
1669
1670 void SwigDirector_ViewImpl::OnStageDisconnection() {
1671   if (!swig_callbackOnStageDisconnection) {
1672     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1673     return;
1674   } else {
1675     swig_callbackOnStageDisconnection();
1676   }
1677 }
1678
1679 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1680   void * jchild = 0 ;
1681
1682   if (!swig_callbackOnChildAdd) {
1683     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1684     return;
1685   } else {
1686     jchild = (Dali::Actor *) &child;
1687     swig_callbackOnChildAdd(jchild);
1688   }
1689 }
1690
1691 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1692   void * jchild = 0 ;
1693
1694   if (!swig_callbackOnChildRemove) {
1695     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1696     return;
1697   } else {
1698     jchild = (Dali::Actor *) &child;
1699     swig_callbackOnChildRemove(jchild);
1700   }
1701 }
1702
1703 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1704   int jindex  ;
1705   void * jpropertyValue  ;
1706
1707   if (!swig_callbackOnPropertySet) {
1708     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1709     return;
1710   } else {
1711     jindex = index;
1712     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1713     swig_callbackOnPropertySet(jindex, jpropertyValue);
1714   }
1715 }
1716
1717 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1718   void * jtargetSize = 0 ;
1719
1720   if (!swig_callbackOnSizeSet) {
1721     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1722     return;
1723   } else {
1724     jtargetSize = (Dali::Vector3 *) &targetSize;
1725     swig_callbackOnSizeSet(jtargetSize);
1726   }
1727 }
1728
1729 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1730   void * janimation = 0 ;
1731   void * jtargetSize = 0 ;
1732
1733   if (!swig_callbackOnSizeAnimation) {
1734     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1735     return;
1736   } else {
1737     janimation = (Dali::Animation *) &animation;
1738     jtargetSize = (Dali::Vector3 *) &targetSize;
1739     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1740   }
1741 }
1742
1743 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1744   bool c_result = SwigValueInit< bool >() ;
1745   unsigned int jresult = 0 ;
1746   void * jarg0 = 0 ;
1747
1748   if (!swig_callbackOnTouchEvent) {
1749     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1750   } else {
1751     jarg0 = (Dali::TouchEvent *) &event;
1752     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1753     c_result = jresult ? true : false;
1754   }
1755   return c_result;
1756 }
1757
1758 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1759   bool c_result = SwigValueInit< bool >() ;
1760   unsigned int jresult = 0 ;
1761   void * jarg0 = 0 ;
1762
1763   if (!swig_callbackOnHoverEvent) {
1764     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1765   } else {
1766     jarg0 = (Dali::HoverEvent *) &event;
1767     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1768     c_result = jresult ? true : false;
1769   }
1770   return c_result;
1771 }
1772
1773 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1774   bool c_result = SwigValueInit< bool >() ;
1775   unsigned int jresult = 0 ;
1776   void * jarg0 = 0 ;
1777
1778   if (!swig_callbackOnKeyEvent) {
1779     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1780   } else {
1781     jarg0 = (Dali::KeyEvent *) &event;
1782     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1783     c_result = jresult ? true : false;
1784   }
1785   return c_result;
1786 }
1787
1788 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1789   bool c_result = SwigValueInit< bool >() ;
1790   unsigned int jresult = 0 ;
1791   void * jarg0 = 0 ;
1792
1793   if (!swig_callbackOnWheelEvent) {
1794     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1795   } else {
1796     jarg0 = (Dali::WheelEvent *) &event;
1797     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1798     c_result = jresult ? true : false;
1799   }
1800   return c_result;
1801 }
1802
1803 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1804   void * jsize = 0 ;
1805   void * jcontainer = 0 ;
1806
1807   if (!swig_callbackOnRelayout) {
1808     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1809     return;
1810   } else {
1811     jsize = (Dali::Vector2 *) &size;
1812     jcontainer = (Dali::RelayoutContainer *) &container;
1813     swig_callbackOnRelayout(jsize, jcontainer);
1814   }
1815 }
1816
1817 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1818   int jpolicy  ;
1819   int jdimension  ;
1820
1821   if (!swig_callbackOnSetResizePolicy) {
1822     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1823     return;
1824   } else {
1825     jpolicy = (int)policy;
1826     jdimension = (int)dimension;
1827     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1828   }
1829 }
1830
1831 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1832   Dali::Vector3 c_result ;
1833   void * jresult = 0 ;
1834
1835   if (!swig_callbackGetNaturalSize) {
1836     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1837   } else {
1838     jresult = (void *) swig_callbackGetNaturalSize();
1839     if (!jresult) {
1840       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1841       return c_result;
1842     }
1843     c_result = *(Dali::Vector3 *)jresult;
1844   }
1845   return c_result;
1846 }
1847
1848 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1849   float c_result = SwigValueInit< float >() ;
1850   float jresult = 0 ;
1851   void * jchild = 0 ;
1852   int jdimension  ;
1853
1854   if (!swig_callbackCalculateChildSize) {
1855     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1856   } else {
1857     jchild = (Dali::Actor *) &child;
1858     jdimension = (int)dimension;
1859     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1860     c_result = (float)jresult;
1861   }
1862   return c_result;
1863 }
1864
1865 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1866   float c_result = SwigValueInit< float >() ;
1867   float jresult = 0 ;
1868   float jwidth  ;
1869
1870   if (!swig_callbackGetHeightForWidth) {
1871     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1872   } else {
1873     jwidth = width;
1874     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1875     c_result = (float)jresult;
1876   }
1877   return c_result;
1878 }
1879
1880 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1881   float c_result = SwigValueInit< float >() ;
1882   float jresult = 0 ;
1883   float jheight  ;
1884
1885   if (!swig_callbackGetWidthForHeight) {
1886     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1887   } else {
1888     jheight = height;
1889     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1890     c_result = (float)jresult;
1891   }
1892   return c_result;
1893 }
1894
1895 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1896   bool c_result = SwigValueInit< bool >() ;
1897   unsigned int jresult = 0 ;
1898   int jdimension  ;
1899
1900   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1901     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1902   } else {
1903     jdimension = (int)dimension;
1904     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1905     c_result = jresult ? true : false;
1906   }
1907   return c_result;
1908 }
1909
1910 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1911   int jdimension  ;
1912
1913   if (!swig_callbackOnCalculateRelayoutSize) {
1914     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1915     return;
1916   } else {
1917     jdimension = (int)dimension;
1918     swig_callbackOnCalculateRelayoutSize(jdimension);
1919   }
1920 }
1921
1922 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1923   float jsize  ;
1924   int jdimension  ;
1925
1926   if (!swig_callbackOnLayoutNegotiated) {
1927     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1928     return;
1929   } else {
1930     jsize = size;
1931     jdimension = (int)dimension;
1932     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1933   }
1934 }
1935
1936 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1937   return Dali::CustomActorImpl::GetExtension();
1938 }
1939
1940 void SwigDirector_ViewImpl::OnInitialize() {
1941   if (!swig_callbackOnInitialize) {
1942     Dali::Toolkit::Internal::Control::OnInitialize();
1943     return;
1944   } else {
1945     swig_callbackOnInitialize();
1946   }
1947 }
1948
1949 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1950   void * jchild = 0 ;
1951
1952   if (!swig_callbackOnControlChildAdd) {
1953     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1954     return;
1955   } else {
1956     jchild = (Dali::Actor *) &child;
1957     swig_callbackOnControlChildAdd(jchild);
1958   }
1959 }
1960
1961 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1962   void * jchild = 0 ;
1963
1964   if (!swig_callbackOnControlChildRemove) {
1965     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1966     return;
1967   } else {
1968     jchild = (Dali::Actor *) &child;
1969     swig_callbackOnControlChildRemove(jchild);
1970   }
1971 }
1972
1973 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1974   void * jstyleManager  ;
1975   int jchange  ;
1976
1977   if (!swig_callbackOnStyleChange) {
1978     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1979     return;
1980   } else {
1981     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1982     jchange = (int)change;
1983     swig_callbackOnStyleChange(jstyleManager, jchange);
1984   }
1985 }
1986
1987 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1988   bool c_result = SwigValueInit< bool >() ;
1989   unsigned int jresult = 0 ;
1990
1991   if (!swig_callbackOnAccessibilityActivated) {
1992     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1993   } else {
1994     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1995     c_result = jresult ? true : false;
1996   }
1997   return c_result;
1998 }
1999
2000 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2001   bool c_result = SwigValueInit< bool >() ;
2002   unsigned int jresult = 0 ;
2003   void * jgesture  ;
2004
2005   if (!swig_callbackOnAccessibilityPan) {
2006     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2007   } else {
2008     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2009     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2010     c_result = jresult ? true : false;
2011   }
2012   return c_result;
2013 }
2014
2015 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2016   bool c_result = SwigValueInit< bool >() ;
2017   unsigned int jresult = 0 ;
2018   void * jtouchEvent = 0 ;
2019
2020   if (!swig_callbackOnAccessibilityTouch) {
2021     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2022   } else {
2023     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2024     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2025     c_result = jresult ? true : false;
2026   }
2027   return c_result;
2028 }
2029
2030 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2031   bool c_result = SwigValueInit< bool >() ;
2032   unsigned int jresult = 0 ;
2033   unsigned int jisIncrease  ;
2034
2035   if (!swig_callbackOnAccessibilityValueChange) {
2036     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2037   } else {
2038     jisIncrease = isIncrease;
2039     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2040     c_result = jresult ? true : false;
2041   }
2042   return c_result;
2043 }
2044
2045 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2046   bool c_result = SwigValueInit< bool >() ;
2047   unsigned int jresult = 0 ;
2048
2049   if (!swig_callbackOnAccessibilityZoom) {
2050     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2051   } else {
2052     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2053     c_result = jresult ? true : false;
2054   }
2055   return c_result;
2056 }
2057
2058 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2059   if (!swig_callbackOnKeyInputFocusGained) {
2060     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2061     return;
2062   } else {
2063     swig_callbackOnKeyInputFocusGained();
2064   }
2065 }
2066
2067 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2068   if (!swig_callbackOnKeyInputFocusLost) {
2069     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2070     return;
2071   } else {
2072     swig_callbackOnKeyInputFocusLost();
2073   }
2074 }
2075
2076 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2077   Dali::Actor c_result ;
2078   void * jresult = 0 ;
2079   void * jcurrentFocusedActor  ;
2080   int jdirection  ;
2081   unsigned int jloopEnabled  ;
2082
2083   if (!swig_callbackGetNextKeyboardFocusableActor) {
2084     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2085   } else {
2086     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2087     jdirection = (int)direction;
2088     jloopEnabled = loopEnabled;
2089     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2090     if (!jresult) {
2091       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2092       return c_result;
2093     }
2094     c_result = *(Dali::Actor *)jresult;
2095   }
2096   return c_result;
2097 }
2098
2099 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2100   void * jcommitedFocusableActor  ;
2101
2102   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2103     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2104     return;
2105   } else {
2106     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2107     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2108   }
2109 }
2110
2111 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2112   bool c_result = SwigValueInit< bool >() ;
2113   unsigned int jresult = 0 ;
2114
2115   if (!swig_callbackOnKeyboardEnter) {
2116     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2117   } else {
2118     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2119     c_result = jresult ? true : false;
2120   }
2121   return c_result;
2122 }
2123
2124 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2125   void * jpinch = 0 ;
2126
2127   if (!swig_callbackOnPinch) {
2128     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2129     return;
2130   } else {
2131     jpinch = (Dali::PinchGesture *) &pinch;
2132     swig_callbackOnPinch(jpinch);
2133   }
2134 }
2135
2136 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2137   void * jpan = 0 ;
2138
2139   if (!swig_callbackOnPan) {
2140     Dali::Toolkit::Internal::Control::OnPan(pan);
2141     return;
2142   } else {
2143     jpan = (Dali::PanGesture *) &pan;
2144     swig_callbackOnPan(jpan);
2145   }
2146 }
2147
2148 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2149   void * jtap = 0 ;
2150
2151   if (!swig_callbackOnTap) {
2152     Dali::Toolkit::Internal::Control::OnTap(tap);
2153     return;
2154   } else {
2155     jtap = (Dali::TapGesture *) &tap;
2156     swig_callbackOnTap(jtap);
2157   }
2158 }
2159
2160 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2161   void * jlongPress = 0 ;
2162
2163   if (!swig_callbackOnLongPress) {
2164     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2165     return;
2166   } else {
2167     jlongPress = (Dali::LongPressGesture *) &longPress;
2168     swig_callbackOnLongPress(jlongPress);
2169   }
2170 }
2171
2172 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2173   void * jslotObserver = 0 ;
2174   void * jcallback = 0 ;
2175
2176   if (!swig_callbackSignalConnected) {
2177     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2178     return;
2179   } else {
2180     jslotObserver = (void *) slotObserver;
2181     jcallback = (void *) callback;
2182     swig_callbackSignalConnected(jslotObserver, jcallback);
2183   }
2184 }
2185
2186 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2187   void * jslotObserver = 0 ;
2188   void * jcallback = 0 ;
2189
2190   if (!swig_callbackSignalDisconnected) {
2191     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2192     return;
2193   } else {
2194     jslotObserver = (void *) slotObserver;
2195     jcallback = (void *) callback;
2196     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2197   }
2198 }
2199
2200 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2201   return Dali::Toolkit::Internal::Control::GetControlExtension();
2202 }
2203
2204 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2205   swig_callbackOnStageConnection = callbackOnStageConnection;
2206   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2207   swig_callbackOnChildAdd = callbackOnChildAdd;
2208   swig_callbackOnChildRemove = callbackOnChildRemove;
2209   swig_callbackOnPropertySet = callbackOnPropertySet;
2210   swig_callbackOnSizeSet = callbackOnSizeSet;
2211   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2212   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2213   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2214   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2215   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2216   swig_callbackOnRelayout = callbackOnRelayout;
2217   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2218   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2219   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2220   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2221   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2222   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2223   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2224   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2225   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2226   swig_callbackOnInitialize = callbackOnInitialize;
2227   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2228   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2229   swig_callbackOnStyleChange = callbackOnStyleChange;
2230   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2231   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2232   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2233   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2234   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2235   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2236   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2237   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2238   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2239   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2240   swig_callbackOnPinch = callbackOnPinch;
2241   swig_callbackOnPan = callbackOnPan;
2242   swig_callbackOnTap = callbackOnTap;
2243   swig_callbackOnLongPress = callbackOnLongPress;
2244   swig_callbackSignalConnected = callbackSignalConnected;
2245   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2246 }
2247
2248 void SwigDirector_ViewImpl::swig_init_callbacks() {
2249   swig_callbackOnStageConnection = 0;
2250   swig_callbackOnStageDisconnection = 0;
2251   swig_callbackOnChildAdd = 0;
2252   swig_callbackOnChildRemove = 0;
2253   swig_callbackOnPropertySet = 0;
2254   swig_callbackOnSizeSet = 0;
2255   swig_callbackOnSizeAnimation = 0;
2256   swig_callbackOnTouchEvent = 0;
2257   swig_callbackOnHoverEvent = 0;
2258   swig_callbackOnKeyEvent = 0;
2259   swig_callbackOnWheelEvent = 0;
2260   swig_callbackOnRelayout = 0;
2261   swig_callbackOnSetResizePolicy = 0;
2262   swig_callbackGetNaturalSize = 0;
2263   swig_callbackCalculateChildSize = 0;
2264   swig_callbackGetHeightForWidth = 0;
2265   swig_callbackGetWidthForHeight = 0;
2266   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2267   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2268   swig_callbackOnCalculateRelayoutSize = 0;
2269   swig_callbackOnLayoutNegotiated = 0;
2270   swig_callbackOnInitialize = 0;
2271   swig_callbackOnControlChildAdd = 0;
2272   swig_callbackOnControlChildRemove = 0;
2273   swig_callbackOnStyleChange = 0;
2274   swig_callbackOnAccessibilityActivated = 0;
2275   swig_callbackOnAccessibilityPan = 0;
2276   swig_callbackOnAccessibilityTouch = 0;
2277   swig_callbackOnAccessibilityValueChange = 0;
2278   swig_callbackOnAccessibilityZoom = 0;
2279   swig_callbackOnKeyInputFocusGained = 0;
2280   swig_callbackOnKeyInputFocusLost = 0;
2281   swig_callbackGetNextKeyboardFocusableActor = 0;
2282   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2283   swig_callbackOnKeyboardEnter = 0;
2284   swig_callbackOnPinch = 0;
2285   swig_callbackOnPan = 0;
2286   swig_callbackOnTap = 0;
2287   swig_callbackOnLongPress = 0;
2288   swig_callbackSignalConnected = 0;
2289   swig_callbackSignalDisconnected = 0;
2290 }
2291
2292 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2293   swig_init_callbacks();
2294 }
2295
2296 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2297
2298 }
2299
2300
2301 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2302   unsigned int c_result = SwigValueInit< unsigned int >() ;
2303   unsigned int jresult = 0 ;
2304
2305   if (!swig_callbackGetNumberOfItems) {
2306     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2307   } else {
2308     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2309     c_result = (unsigned int)jresult;
2310   }
2311   return c_result;
2312 }
2313
2314 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2315   Dali::Actor c_result ;
2316   void * jresult = 0 ;
2317   unsigned int jitemId  ;
2318
2319   if (!swig_callbackNewItem) {
2320     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2321   } else {
2322     jitemId = itemId;
2323     jresult = (void *) swig_callbackNewItem(jitemId);
2324     if (!jresult) {
2325       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2326       return c_result;
2327     }
2328     c_result = *(Dali::Actor *)jresult;
2329   }
2330   return c_result;
2331 }
2332
2333 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2334   unsigned int jitemId  ;
2335   void * jactor  ;
2336
2337   if (!swig_callbackItemReleased) {
2338     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2339     return;
2340   } else {
2341     jitemId = itemId;
2342     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2343     swig_callbackItemReleased(jitemId, jactor);
2344   }
2345 }
2346
2347 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2348   return Dali::Toolkit::ItemFactory::GetExtension();
2349 }
2350
2351 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2352   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2353   swig_callbackNewItem = callbackNewItem;
2354   swig_callbackItemReleased = callbackItemReleased;
2355 }
2356
2357 void SwigDirector_ItemFactory::swig_init_callbacks() {
2358   swig_callbackGetNumberOfItems = 0;
2359   swig_callbackNewItem = 0;
2360   swig_callbackItemReleased = 0;
2361 }
2362
2363
2364 #ifdef __cplusplus
2365 extern "C" {
2366 #endif
2367
2368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2369   void * jresult ;
2370   floatp *result = 0 ;
2371
2372   {
2373     try {
2374       result = (floatp *)new_floatp();
2375     } catch (std::out_of_range& e) {
2376       {
2377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2378       };
2379     } catch (std::exception& e) {
2380       {
2381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2382       };
2383     } catch (...) {
2384       {
2385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2386       };
2387     }
2388   }
2389   jresult = (void *)result;
2390   return jresult;
2391 }
2392
2393
2394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2395   floatp *arg1 = (floatp *) 0 ;
2396
2397   arg1 = (floatp *)jarg1;
2398   {
2399     try {
2400       delete_floatp(arg1);
2401     } catch (std::out_of_range& e) {
2402       {
2403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2404       };
2405     } catch (std::exception& e) {
2406       {
2407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2408       };
2409     } catch (...) {
2410       {
2411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2412       };
2413     }
2414   }
2415 }
2416
2417
2418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2419   floatp *arg1 = (floatp *) 0 ;
2420   float arg2 ;
2421
2422   arg1 = (floatp *)jarg1;
2423   arg2 = (float)jarg2;
2424   {
2425     try {
2426       floatp_assign(arg1,arg2);
2427     } catch (std::out_of_range& e) {
2428       {
2429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2430       };
2431     } catch (std::exception& e) {
2432       {
2433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2434       };
2435     } catch (...) {
2436       {
2437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2438       };
2439     }
2440   }
2441 }
2442
2443
2444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2445   float jresult ;
2446   floatp *arg1 = (floatp *) 0 ;
2447   float result;
2448
2449   arg1 = (floatp *)jarg1;
2450   {
2451     try {
2452       result = (float)floatp_value(arg1);
2453     } catch (std::out_of_range& e) {
2454       {
2455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2456       };
2457     } catch (std::exception& e) {
2458       {
2459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2460       };
2461     } catch (...) {
2462       {
2463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2464       };
2465     }
2466   }
2467   jresult = result;
2468   return jresult;
2469 }
2470
2471
2472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2473   void * jresult ;
2474   floatp *arg1 = (floatp *) 0 ;
2475   float *result = 0 ;
2476
2477   arg1 = (floatp *)jarg1;
2478   {
2479     try {
2480       result = (float *)floatp_cast(arg1);
2481     } catch (std::out_of_range& e) {
2482       {
2483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2484       };
2485     } catch (std::exception& e) {
2486       {
2487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2488       };
2489     } catch (...) {
2490       {
2491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2492       };
2493     }
2494   }
2495   jresult = (void *)result;
2496   return jresult;
2497 }
2498
2499
2500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2501   void * jresult ;
2502   float *arg1 = (float *) 0 ;
2503   floatp *result = 0 ;
2504
2505   arg1 = (float *)jarg1;
2506   {
2507     try {
2508       result = (floatp *)floatp_frompointer(arg1);
2509     } catch (std::out_of_range& e) {
2510       {
2511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2512       };
2513     } catch (std::exception& e) {
2514       {
2515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2516       };
2517     } catch (...) {
2518       {
2519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2520       };
2521     }
2522   }
2523   jresult = (void *)result;
2524   return jresult;
2525 }
2526
2527
2528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2529   void * jresult ;
2530   intp *result = 0 ;
2531
2532   {
2533     try {
2534       result = (intp *)new_intp();
2535     } catch (std::out_of_range& e) {
2536       {
2537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2538       };
2539     } catch (std::exception& e) {
2540       {
2541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2542       };
2543     } catch (...) {
2544       {
2545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2546       };
2547     }
2548   }
2549   jresult = (void *)result;
2550   return jresult;
2551 }
2552
2553
2554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2555   intp *arg1 = (intp *) 0 ;
2556
2557   arg1 = (intp *)jarg1;
2558   {
2559     try {
2560       delete_intp(arg1);
2561     } catch (std::out_of_range& e) {
2562       {
2563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2564       };
2565     } catch (std::exception& e) {
2566       {
2567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2568       };
2569     } catch (...) {
2570       {
2571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2572       };
2573     }
2574   }
2575 }
2576
2577
2578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2579   intp *arg1 = (intp *) 0 ;
2580   int arg2 ;
2581
2582   arg1 = (intp *)jarg1;
2583   arg2 = (int)jarg2;
2584   {
2585     try {
2586       intp_assign(arg1,arg2);
2587     } catch (std::out_of_range& e) {
2588       {
2589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2590       };
2591     } catch (std::exception& e) {
2592       {
2593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2594       };
2595     } catch (...) {
2596       {
2597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2598       };
2599     }
2600   }
2601 }
2602
2603
2604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2605   int jresult ;
2606   intp *arg1 = (intp *) 0 ;
2607   int result;
2608
2609   arg1 = (intp *)jarg1;
2610   {
2611     try {
2612       result = (int)intp_value(arg1);
2613     } catch (std::out_of_range& e) {
2614       {
2615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2616       };
2617     } catch (std::exception& e) {
2618       {
2619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2620       };
2621     } catch (...) {
2622       {
2623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2624       };
2625     }
2626   }
2627   jresult = result;
2628   return jresult;
2629 }
2630
2631
2632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2633   void * jresult ;
2634   intp *arg1 = (intp *) 0 ;
2635   int *result = 0 ;
2636
2637   arg1 = (intp *)jarg1;
2638   {
2639     try {
2640       result = (int *)intp_cast(arg1);
2641     } catch (std::out_of_range& e) {
2642       {
2643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2644       };
2645     } catch (std::exception& e) {
2646       {
2647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2648       };
2649     } catch (...) {
2650       {
2651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2652       };
2653     }
2654   }
2655   jresult = (void *)result;
2656   return jresult;
2657 }
2658
2659
2660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2661   void * jresult ;
2662   int *arg1 = (int *) 0 ;
2663   intp *result = 0 ;
2664
2665   arg1 = (int *)jarg1;
2666   {
2667     try {
2668       result = (intp *)intp_frompointer(arg1);
2669     } catch (std::out_of_range& e) {
2670       {
2671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2672       };
2673     } catch (std::exception& e) {
2674       {
2675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2676       };
2677     } catch (...) {
2678       {
2679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2680       };
2681     }
2682   }
2683   jresult = (void *)result;
2684   return jresult;
2685 }
2686
2687
2688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2689   void * jresult ;
2690   doublep *result = 0 ;
2691
2692   {
2693     try {
2694       result = (doublep *)new_doublep();
2695     } catch (std::out_of_range& e) {
2696       {
2697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2698       };
2699     } catch (std::exception& e) {
2700       {
2701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2702       };
2703     } catch (...) {
2704       {
2705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2706       };
2707     }
2708   }
2709   jresult = (void *)result;
2710   return jresult;
2711 }
2712
2713
2714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2715   doublep *arg1 = (doublep *) 0 ;
2716
2717   arg1 = (doublep *)jarg1;
2718   {
2719     try {
2720       delete_doublep(arg1);
2721     } catch (std::out_of_range& e) {
2722       {
2723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2724       };
2725     } catch (std::exception& e) {
2726       {
2727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2728       };
2729     } catch (...) {
2730       {
2731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2732       };
2733     }
2734   }
2735 }
2736
2737
2738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2739   doublep *arg1 = (doublep *) 0 ;
2740   double arg2 ;
2741
2742   arg1 = (doublep *)jarg1;
2743   arg2 = (double)jarg2;
2744   {
2745     try {
2746       doublep_assign(arg1,arg2);
2747     } catch (std::out_of_range& e) {
2748       {
2749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2750       };
2751     } catch (std::exception& e) {
2752       {
2753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2754       };
2755     } catch (...) {
2756       {
2757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2758       };
2759     }
2760   }
2761 }
2762
2763
2764 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2765   double jresult ;
2766   doublep *arg1 = (doublep *) 0 ;
2767   double result;
2768
2769   arg1 = (doublep *)jarg1;
2770   {
2771     try {
2772       result = (double)doublep_value(arg1);
2773     } catch (std::out_of_range& e) {
2774       {
2775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2776       };
2777     } catch (std::exception& e) {
2778       {
2779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2780       };
2781     } catch (...) {
2782       {
2783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2784       };
2785     }
2786   }
2787   jresult = result;
2788   return jresult;
2789 }
2790
2791
2792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2793   void * jresult ;
2794   doublep *arg1 = (doublep *) 0 ;
2795   double *result = 0 ;
2796
2797   arg1 = (doublep *)jarg1;
2798   {
2799     try {
2800       result = (double *)doublep_cast(arg1);
2801     } catch (std::out_of_range& e) {
2802       {
2803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2804       };
2805     } catch (std::exception& e) {
2806       {
2807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2808       };
2809     } catch (...) {
2810       {
2811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2812       };
2813     }
2814   }
2815   jresult = (void *)result;
2816   return jresult;
2817 }
2818
2819
2820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2821   void * jresult ;
2822   double *arg1 = (double *) 0 ;
2823   doublep *result = 0 ;
2824
2825   arg1 = (double *)jarg1;
2826   {
2827     try {
2828       result = (doublep *)doublep_frompointer(arg1);
2829     } catch (std::out_of_range& e) {
2830       {
2831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2832       };
2833     } catch (std::exception& e) {
2834       {
2835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2836       };
2837     } catch (...) {
2838       {
2839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2840       };
2841     }
2842   }
2843   jresult = (void *)result;
2844   return jresult;
2845 }
2846
2847
2848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2849   void * jresult ;
2850   uintp *result = 0 ;
2851
2852   {
2853     try {
2854       result = (uintp *)new_uintp();
2855     } catch (std::out_of_range& e) {
2856       {
2857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2858       };
2859     } catch (std::exception& e) {
2860       {
2861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2862       };
2863     } catch (...) {
2864       {
2865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2866       };
2867     }
2868   }
2869   jresult = (void *)result;
2870   return jresult;
2871 }
2872
2873
2874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2875   uintp *arg1 = (uintp *) 0 ;
2876
2877   arg1 = (uintp *)jarg1;
2878   {
2879     try {
2880       delete_uintp(arg1);
2881     } catch (std::out_of_range& e) {
2882       {
2883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2884       };
2885     } catch (std::exception& e) {
2886       {
2887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2888       };
2889     } catch (...) {
2890       {
2891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2892       };
2893     }
2894   }
2895 }
2896
2897
2898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2899   uintp *arg1 = (uintp *) 0 ;
2900   unsigned int arg2 ;
2901
2902   arg1 = (uintp *)jarg1;
2903   arg2 = (unsigned int)jarg2;
2904   {
2905     try {
2906       uintp_assign(arg1,arg2);
2907     } catch (std::out_of_range& e) {
2908       {
2909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2910       };
2911     } catch (std::exception& e) {
2912       {
2913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2914       };
2915     } catch (...) {
2916       {
2917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2918       };
2919     }
2920   }
2921 }
2922
2923
2924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2925   unsigned int jresult ;
2926   uintp *arg1 = (uintp *) 0 ;
2927   unsigned int result;
2928
2929   arg1 = (uintp *)jarg1;
2930   {
2931     try {
2932       result = (unsigned int)uintp_value(arg1);
2933     } catch (std::out_of_range& e) {
2934       {
2935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2936       };
2937     } catch (std::exception& e) {
2938       {
2939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2940       };
2941     } catch (...) {
2942       {
2943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2944       };
2945     }
2946   }
2947   jresult = result;
2948   return jresult;
2949 }
2950
2951
2952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2953   void * jresult ;
2954   uintp *arg1 = (uintp *) 0 ;
2955   unsigned int *result = 0 ;
2956
2957   arg1 = (uintp *)jarg1;
2958   {
2959     try {
2960       result = (unsigned int *)uintp_cast(arg1);
2961     } catch (std::out_of_range& e) {
2962       {
2963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2964       };
2965     } catch (std::exception& e) {
2966       {
2967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2968       };
2969     } catch (...) {
2970       {
2971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2972       };
2973     }
2974   }
2975   jresult = (void *)result;
2976   return jresult;
2977 }
2978
2979
2980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2981   void * jresult ;
2982   unsigned int *arg1 = (unsigned int *) 0 ;
2983   uintp *result = 0 ;
2984
2985   arg1 = (unsigned int *)jarg1;
2986   {
2987     try {
2988       result = (uintp *)uintp_frompointer(arg1);
2989     } catch (std::out_of_range& e) {
2990       {
2991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2992       };
2993     } catch (std::exception& e) {
2994       {
2995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2996       };
2997     } catch (...) {
2998       {
2999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3000       };
3001     }
3002   }
3003   jresult = (void *)result;
3004   return jresult;
3005 }
3006
3007
3008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3009   void * jresult ;
3010   ushortp *result = 0 ;
3011
3012   {
3013     try {
3014       result = (ushortp *)new_ushortp();
3015     } catch (std::out_of_range& e) {
3016       {
3017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3018       };
3019     } catch (std::exception& e) {
3020       {
3021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3022       };
3023     } catch (...) {
3024       {
3025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3026       };
3027     }
3028   }
3029   jresult = (void *)result;
3030   return jresult;
3031 }
3032
3033
3034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3035   ushortp *arg1 = (ushortp *) 0 ;
3036
3037   arg1 = (ushortp *)jarg1;
3038   {
3039     try {
3040       delete_ushortp(arg1);
3041     } catch (std::out_of_range& e) {
3042       {
3043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3044       };
3045     } catch (std::exception& e) {
3046       {
3047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3048       };
3049     } catch (...) {
3050       {
3051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3052       };
3053     }
3054   }
3055 }
3056
3057
3058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3059   ushortp *arg1 = (ushortp *) 0 ;
3060   unsigned short arg2 ;
3061
3062   arg1 = (ushortp *)jarg1;
3063   arg2 = (unsigned short)jarg2;
3064   {
3065     try {
3066       ushortp_assign(arg1,arg2);
3067     } catch (std::out_of_range& e) {
3068       {
3069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3070       };
3071     } catch (std::exception& e) {
3072       {
3073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3074       };
3075     } catch (...) {
3076       {
3077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3078       };
3079     }
3080   }
3081 }
3082
3083
3084 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3085   unsigned short jresult ;
3086   ushortp *arg1 = (ushortp *) 0 ;
3087   unsigned short result;
3088
3089   arg1 = (ushortp *)jarg1;
3090   {
3091     try {
3092       result = (unsigned short)ushortp_value(arg1);
3093     } catch (std::out_of_range& e) {
3094       {
3095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3096       };
3097     } catch (std::exception& e) {
3098       {
3099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3100       };
3101     } catch (...) {
3102       {
3103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3104       };
3105     }
3106   }
3107   jresult = result;
3108   return jresult;
3109 }
3110
3111
3112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3113   void * jresult ;
3114   ushortp *arg1 = (ushortp *) 0 ;
3115   unsigned short *result = 0 ;
3116
3117   arg1 = (ushortp *)jarg1;
3118   {
3119     try {
3120       result = (unsigned short *)ushortp_cast(arg1);
3121     } catch (std::out_of_range& e) {
3122       {
3123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3124       };
3125     } catch (std::exception& e) {
3126       {
3127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3128       };
3129     } catch (...) {
3130       {
3131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3132       };
3133     }
3134   }
3135   jresult = (void *)result;
3136   return jresult;
3137 }
3138
3139
3140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3141   void * jresult ;
3142   unsigned short *arg1 = (unsigned short *) 0 ;
3143   ushortp *result = 0 ;
3144
3145   arg1 = (unsigned short *)jarg1;
3146   {
3147     try {
3148       result = (ushortp *)ushortp_frompointer(arg1);
3149     } catch (std::out_of_range& e) {
3150       {
3151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3152       };
3153     } catch (std::exception& e) {
3154       {
3155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3156       };
3157     } catch (...) {
3158       {
3159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3160       };
3161     }
3162   }
3163   jresult = (void *)result;
3164   return jresult;
3165 }
3166
3167
3168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3169   unsigned int jresult ;
3170   int arg1 ;
3171   unsigned int result;
3172
3173   arg1 = (int)jarg1;
3174   {
3175     try {
3176       result = (unsigned int)int_to_uint(arg1);
3177     } catch (std::out_of_range& e) {
3178       {
3179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3180       };
3181     } catch (std::exception& e) {
3182       {
3183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3184       };
3185     } catch (...) {
3186       {
3187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3188       };
3189     }
3190   }
3191   jresult = result;
3192   return jresult;
3193 }
3194
3195
3196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3197   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3198
3199   arg1 = (Dali::RefObject *)jarg1;
3200   {
3201     try {
3202       (arg1)->Reference();
3203     } catch (std::out_of_range& e) {
3204       {
3205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3206       };
3207     } catch (std::exception& e) {
3208       {
3209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3210       };
3211     } catch (...) {
3212       {
3213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3214       };
3215     }
3216   }
3217 }
3218
3219
3220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3221   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3222
3223   arg1 = (Dali::RefObject *)jarg1;
3224   {
3225     try {
3226       (arg1)->Unreference();
3227     } catch (std::out_of_range& e) {
3228       {
3229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3230       };
3231     } catch (std::exception& e) {
3232       {
3233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3234       };
3235     } catch (...) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3238       };
3239     }
3240   }
3241 }
3242
3243
3244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3245   int jresult ;
3246   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3247   int result;
3248
3249   arg1 = (Dali::RefObject *)jarg1;
3250   {
3251     try {
3252       result = (int)(arg1)->ReferenceCount();
3253     } catch (std::out_of_range& e) {
3254       {
3255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3256       };
3257     } catch (std::exception& e) {
3258       {
3259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3260       };
3261     } catch (...) {
3262       {
3263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3264       };
3265     }
3266   }
3267   jresult = result;
3268   return jresult;
3269 }
3270
3271
3272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3273   void * jresult ;
3274   Dali::Any *result = 0 ;
3275
3276   {
3277     try {
3278       result = (Dali::Any *)new Dali::Any();
3279     } catch (std::out_of_range& e) {
3280       {
3281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3282       };
3283     } catch (std::exception& e) {
3284       {
3285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3286       };
3287     } catch (...) {
3288       {
3289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3290       };
3291     }
3292   }
3293   jresult = (void *)result;
3294   return jresult;
3295 }
3296
3297
3298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3299   Dali::Any *arg1 = (Dali::Any *) 0 ;
3300
3301   arg1 = (Dali::Any *)jarg1;
3302   {
3303     try {
3304       delete arg1;
3305     } catch (std::out_of_range& e) {
3306       {
3307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3308       };
3309     } catch (std::exception& e) {
3310       {
3311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3312       };
3313     } catch (...) {
3314       {
3315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3316       };
3317     }
3318   }
3319 }
3320
3321
3322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3323   char *arg1 = (char *) 0 ;
3324
3325   arg1 = (char *)jarg1;
3326   {
3327     try {
3328       Dali::Any::AssertAlways((char const *)arg1);
3329     } catch (std::out_of_range& e) {
3330       {
3331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3332       };
3333     } catch (std::exception& e) {
3334       {
3335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3336       };
3337     } catch (...) {
3338       {
3339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3340       };
3341     }
3342   }
3343 }
3344
3345
3346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3347   void * jresult ;
3348   Dali::Any *arg1 = 0 ;
3349   Dali::Any *result = 0 ;
3350
3351   arg1 = (Dali::Any *)jarg1;
3352   if (!arg1) {
3353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3354     return 0;
3355   }
3356   {
3357     try {
3358       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3359     } catch (std::out_of_range& e) {
3360       {
3361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3362       };
3363     } catch (std::exception& e) {
3364       {
3365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3366       };
3367     } catch (...) {
3368       {
3369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3370       };
3371     }
3372   }
3373   jresult = (void *)result;
3374   return jresult;
3375 }
3376
3377
3378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3379   void * jresult ;
3380   Dali::Any *arg1 = (Dali::Any *) 0 ;
3381   Dali::Any *arg2 = 0 ;
3382   Dali::Any *result = 0 ;
3383
3384   arg1 = (Dali::Any *)jarg1;
3385   arg2 = (Dali::Any *)jarg2;
3386   if (!arg2) {
3387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3388     return 0;
3389   }
3390   {
3391     try {
3392       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3393     } catch (std::out_of_range& e) {
3394       {
3395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3396       };
3397     } catch (std::exception& e) {
3398       {
3399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3400       };
3401     } catch (...) {
3402       {
3403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3404       };
3405     }
3406   }
3407   jresult = (void *)result;
3408   return jresult;
3409 }
3410
3411
3412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3413   void * jresult ;
3414   Dali::Any *arg1 = (Dali::Any *) 0 ;
3415   std::type_info *result = 0 ;
3416
3417   arg1 = (Dali::Any *)jarg1;
3418   {
3419     try {
3420       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3421     } catch (std::out_of_range& e) {
3422       {
3423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3424       };
3425     } catch (std::exception& e) {
3426       {
3427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3432       };
3433     }
3434   }
3435   jresult = (void *)result;
3436   return jresult;
3437 }
3438
3439
3440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3441   unsigned int jresult ;
3442   Dali::Any *arg1 = (Dali::Any *) 0 ;
3443   bool result;
3444
3445   arg1 = (Dali::Any *)jarg1;
3446   {
3447     try {
3448       result = (bool)((Dali::Any const *)arg1)->Empty();
3449     } catch (std::out_of_range& e) {
3450       {
3451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3452       };
3453     } catch (std::exception& e) {
3454       {
3455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3456       };
3457     } catch (...) {
3458       {
3459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3460       };
3461     }
3462   }
3463   jresult = result;
3464   return jresult;
3465 }
3466
3467
3468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3469   void * jresult ;
3470   std::type_info *arg1 = 0 ;
3471   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3472   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3473   Dali::Any::AnyContainerBase *result = 0 ;
3474
3475   arg1 = (std::type_info *)jarg1;
3476   if (!arg1) {
3477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3478     return 0;
3479   }
3480   arg2 = (Dali::Any::CloneFunc)jarg2;
3481   arg3 = (Dali::Any::DeleteFunc)jarg3;
3482   {
3483     try {
3484       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3485     } catch (std::out_of_range& e) {
3486       {
3487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (std::exception& e) {
3490       {
3491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3492       };
3493     } catch (...) {
3494       {
3495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3496       };
3497     }
3498   }
3499   jresult = (void *)result;
3500   return jresult;
3501 }
3502
3503
3504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3505   void * jresult ;
3506   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3507   std::type_info *result = 0 ;
3508
3509   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3510   {
3511     try {
3512       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3513     } catch (std::out_of_range& e) {
3514       {
3515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3516       };
3517     } catch (std::exception& e) {
3518       {
3519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (...) {
3522       {
3523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3524       };
3525     }
3526   }
3527   jresult = (void *)result;
3528   return jresult;
3529 }
3530
3531
3532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3533   void * jresult ;
3534   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3535   ::std::type_info *result = 0 ;
3536
3537   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3538   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3539   jresult = (void *)result;
3540   return jresult;
3541 }
3542
3543
3544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3545   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3546   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3547
3548   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3549   arg2 = (Dali::Any::CloneFunc)jarg2;
3550   if (arg1) (arg1)->mCloneFunc = arg2;
3551 }
3552
3553
3554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3555   void * jresult ;
3556   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3557   Dali::Any::CloneFunc result;
3558
3559   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3560   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3561   jresult = (void *)result;
3562   return jresult;
3563 }
3564
3565
3566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3567   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3568   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3569
3570   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3571   arg2 = (Dali::Any::DeleteFunc)jarg2;
3572   if (arg1) (arg1)->mDeleteFunc = arg2;
3573 }
3574
3575
3576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3577   void * jresult ;
3578   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3579   Dali::Any::DeleteFunc result;
3580
3581   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3582   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3583   jresult = (void *)result;
3584   return jresult;
3585 }
3586
3587
3588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3589   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3590
3591   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3592   {
3593     try {
3594       delete arg1;
3595     } catch (std::out_of_range& e) {
3596       {
3597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3598       };
3599     } catch (std::exception& e) {
3600       {
3601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3602       };
3603     } catch (...) {
3604       {
3605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3606       };
3607     }
3608   }
3609 }
3610
3611
3612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3613   Dali::Any *arg1 = (Dali::Any *) 0 ;
3614   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3615
3616   arg1 = (Dali::Any *)jarg1;
3617   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3618   if (arg1) (arg1)->mContainer = arg2;
3619 }
3620
3621
3622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3623   void * jresult ;
3624   Dali::Any *arg1 = (Dali::Any *) 0 ;
3625   Dali::Any::AnyContainerBase *result = 0 ;
3626
3627   arg1 = (Dali::Any *)jarg1;
3628   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3629   jresult = (void *)result;
3630   return jresult;
3631 }
3632
3633
3634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3635   char *arg1 = (char *) 0 ;
3636   char *arg2 = (char *) 0 ;
3637
3638   arg1 = (char *)jarg1;
3639   arg2 = (char *)jarg2;
3640   {
3641     try {
3642       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3643     } catch (std::out_of_range& e) {
3644       {
3645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3646       };
3647     } catch (std::exception& e) {
3648       {
3649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3650       };
3651     } catch (...) {
3652       {
3653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3654       };
3655     }
3656   }
3657 }
3658
3659
3660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3661   void * jresult ;
3662   char *arg1 = (char *) 0 ;
3663   char *arg2 = (char *) 0 ;
3664   Dali::DaliException *result = 0 ;
3665
3666   arg1 = (char *)jarg1;
3667   arg2 = (char *)jarg2;
3668   {
3669     try {
3670       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3671     } catch (std::out_of_range& e) {
3672       {
3673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3674       };
3675     } catch (std::exception& e) {
3676       {
3677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3678       };
3679     } catch (...) {
3680       {
3681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3682       };
3683     }
3684   }
3685   jresult = (void *)result;
3686   return jresult;
3687 }
3688
3689
3690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3691   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3692   char *arg2 = (char *) 0 ;
3693
3694   arg1 = (Dali::DaliException *)jarg1;
3695   arg2 = (char *)jarg2;
3696   {
3697     if (arg2) {
3698       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3699       strcpy((char *)arg1->location, (const char *)arg2);
3700     } else {
3701       arg1->location = 0;
3702     }
3703   }
3704 }
3705
3706
3707 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3708   char * jresult ;
3709   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3710   char *result = 0 ;
3711
3712   arg1 = (Dali::DaliException *)jarg1;
3713   result = (char *) ((arg1)->location);
3714   jresult = SWIG_csharp_string_callback((const char *)result);
3715   return jresult;
3716 }
3717
3718
3719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3720   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3721   char *arg2 = (char *) 0 ;
3722
3723   arg1 = (Dali::DaliException *)jarg1;
3724   arg2 = (char *)jarg2;
3725   {
3726     if (arg2) {
3727       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3728       strcpy((char *)arg1->condition, (const char *)arg2);
3729     } else {
3730       arg1->condition = 0;
3731     }
3732   }
3733 }
3734
3735
3736 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3737   char * jresult ;
3738   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3739   char *result = 0 ;
3740
3741   arg1 = (Dali::DaliException *)jarg1;
3742   result = (char *) ((arg1)->condition);
3743   jresult = SWIG_csharp_string_callback((const char *)result);
3744   return jresult;
3745 }
3746
3747
3748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3749   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3750
3751   arg1 = (Dali::DaliException *)jarg1;
3752   {
3753     try {
3754       delete arg1;
3755     } catch (std::out_of_range& e) {
3756       {
3757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3758       };
3759     } catch (std::exception& e) {
3760       {
3761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3762       };
3763     } catch (...) {
3764       {
3765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3766       };
3767     }
3768   }
3769 }
3770
3771
3772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3773   void * jresult ;
3774   Dali::Vector2 *result = 0 ;
3775
3776   {
3777     try {
3778       result = (Dali::Vector2 *)new Dali::Vector2();
3779     } catch (std::out_of_range& e) {
3780       {
3781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3782       };
3783     } catch (std::exception& e) {
3784       {
3785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3786       };
3787     } catch (...) {
3788       {
3789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3790       };
3791     }
3792   }
3793   jresult = (void *)result;
3794   return jresult;
3795 }
3796
3797
3798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3799   void * jresult ;
3800   float arg1 ;
3801   float arg2 ;
3802   Dali::Vector2 *result = 0 ;
3803
3804   arg1 = (float)jarg1;
3805   arg2 = (float)jarg2;
3806   {
3807     try {
3808       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3809     } catch (std::out_of_range& e) {
3810       {
3811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (std::exception& e) {
3814       {
3815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823   jresult = (void *)result;
3824   return jresult;
3825 }
3826
3827
3828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3829   void * jresult ;
3830   float *arg1 = (float *) 0 ;
3831   Dali::Vector2 *result = 0 ;
3832
3833   arg1 = jarg1;
3834   {
3835     try {
3836       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3837     } catch (std::out_of_range& e) {
3838       {
3839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3840       };
3841     } catch (std::exception& e) {
3842       {
3843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3844       };
3845     } catch (...) {
3846       {
3847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3848       };
3849     }
3850   }
3851   jresult = (void *)result;
3852
3853
3854   return jresult;
3855 }
3856
3857
3858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3859   void * jresult ;
3860   Dali::Vector3 *arg1 = 0 ;
3861   Dali::Vector2 *result = 0 ;
3862
3863   arg1 = (Dali::Vector3 *)jarg1;
3864   if (!arg1) {
3865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3866     return 0;
3867   }
3868   {
3869     try {
3870       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3871     } catch (std::out_of_range& e) {
3872       {
3873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (std::exception& e) {
3876       {
3877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3878       };
3879     } catch (...) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3882       };
3883     }
3884   }
3885   jresult = (void *)result;
3886   return jresult;
3887 }
3888
3889
3890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3891   void * jresult ;
3892   Dali::Vector4 *arg1 = 0 ;
3893   Dali::Vector2 *result = 0 ;
3894
3895   arg1 = (Dali::Vector4 *)jarg1;
3896   if (!arg1) {
3897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3898     return 0;
3899   }
3900   {
3901     try {
3902       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3903     } catch (std::out_of_range& e) {
3904       {
3905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3906       };
3907     } catch (std::exception& e) {
3908       {
3909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3910       };
3911     } catch (...) {
3912       {
3913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3914       };
3915     }
3916   }
3917   jresult = (void *)result;
3918   return jresult;
3919 }
3920
3921
3922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3923   void * jresult ;
3924   Dali::Vector2 *result = 0 ;
3925
3926   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3927   jresult = (void *)result;
3928   return jresult;
3929 }
3930
3931
3932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3933   void * jresult ;
3934   Dali::Vector2 *result = 0 ;
3935
3936   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3937   jresult = (void *)result;
3938   return jresult;
3939 }
3940
3941
3942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3943   void * jresult ;
3944   Dali::Vector2 *result = 0 ;
3945
3946   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3947   jresult = (void *)result;
3948   return jresult;
3949 }
3950
3951
3952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3953   void * jresult ;
3954   Dali::Vector2 *result = 0 ;
3955
3956   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3957   jresult = (void *)result;
3958   return jresult;
3959 }
3960
3961
3962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3963   void * jresult ;
3964   Dali::Vector2 *result = 0 ;
3965
3966   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3967   jresult = (void *)result;
3968   return jresult;
3969 }
3970
3971
3972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3973   void * jresult ;
3974   Dali::Vector2 *result = 0 ;
3975
3976   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3977   jresult = (void *)result;
3978   return jresult;
3979 }
3980
3981
3982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3983   void * jresult ;
3984   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3985   float *arg2 = (float *) 0 ;
3986   Dali::Vector2 *result = 0 ;
3987
3988   arg1 = (Dali::Vector2 *)jarg1;
3989   arg2 = jarg2;
3990   {
3991     try {
3992       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3993     } catch (std::out_of_range& e) {
3994       {
3995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3996       };
3997     } catch (std::exception& e) {
3998       {
3999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4000       };
4001     } catch (...) {
4002       {
4003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4004       };
4005     }
4006   }
4007   jresult = (void *)result;
4008
4009
4010   return jresult;
4011 }
4012
4013
4014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4015   void * jresult ;
4016   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4017   Dali::Vector3 *arg2 = 0 ;
4018   Dali::Vector2 *result = 0 ;
4019
4020   arg1 = (Dali::Vector2 *)jarg1;
4021   arg2 = (Dali::Vector3 *)jarg2;
4022   if (!arg2) {
4023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4024     return 0;
4025   }
4026   {
4027     try {
4028       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4029     } catch (std::out_of_range& e) {
4030       {
4031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4032       };
4033     } catch (std::exception& e) {
4034       {
4035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4036       };
4037     } catch (...) {
4038       {
4039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4040       };
4041     }
4042   }
4043   jresult = (void *)result;
4044   return jresult;
4045 }
4046
4047
4048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4049   void * jresult ;
4050   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4051   Dali::Vector4 *arg2 = 0 ;
4052   Dali::Vector2 *result = 0 ;
4053
4054   arg1 = (Dali::Vector2 *)jarg1;
4055   arg2 = (Dali::Vector4 *)jarg2;
4056   if (!arg2) {
4057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4058     return 0;
4059   }
4060   {
4061     try {
4062       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4063     } catch (std::out_of_range& e) {
4064       {
4065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4066       };
4067     } catch (std::exception& e) {
4068       {
4069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4070       };
4071     } catch (...) {
4072       {
4073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4074       };
4075     }
4076   }
4077   jresult = (void *)result;
4078   return jresult;
4079 }
4080
4081
4082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4083   void * jresult ;
4084   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4085   Dali::Vector2 *arg2 = 0 ;
4086   Dali::Vector2 result;
4087
4088   arg1 = (Dali::Vector2 *)jarg1;
4089   arg2 = (Dali::Vector2 *)jarg2;
4090   if (!arg2) {
4091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4092     return 0;
4093   }
4094   {
4095     try {
4096       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4097     } catch (std::out_of_range& e) {
4098       {
4099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4100       };
4101     } catch (std::exception& e) {
4102       {
4103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4104       };
4105     } catch (...) {
4106       {
4107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4108       };
4109     }
4110   }
4111   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4112   return jresult;
4113 }
4114
4115
4116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4117   void * jresult ;
4118   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4119   Dali::Vector2 *arg2 = 0 ;
4120   Dali::Vector2 *result = 0 ;
4121
4122   arg1 = (Dali::Vector2 *)jarg1;
4123   arg2 = (Dali::Vector2 *)jarg2;
4124   if (!arg2) {
4125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4126     return 0;
4127   }
4128   {
4129     try {
4130       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4131     } catch (std::out_of_range& e) {
4132       {
4133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4134       };
4135     } catch (std::exception& e) {
4136       {
4137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4138       };
4139     } catch (...) {
4140       {
4141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4142       };
4143     }
4144   }
4145   jresult = (void *)result;
4146   return jresult;
4147 }
4148
4149
4150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4151   void * jresult ;
4152   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4153   Dali::Vector2 *arg2 = 0 ;
4154   Dali::Vector2 result;
4155
4156   arg1 = (Dali::Vector2 *)jarg1;
4157   arg2 = (Dali::Vector2 *)jarg2;
4158   if (!arg2) {
4159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4160     return 0;
4161   }
4162   {
4163     try {
4164       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4165     } catch (std::out_of_range& e) {
4166       {
4167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4168       };
4169     } catch (std::exception& e) {
4170       {
4171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4172       };
4173     } catch (...) {
4174       {
4175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4176       };
4177     }
4178   }
4179   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4180   return jresult;
4181 }
4182
4183
4184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4185   void * jresult ;
4186   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4187   Dali::Vector2 *arg2 = 0 ;
4188   Dali::Vector2 *result = 0 ;
4189
4190   arg1 = (Dali::Vector2 *)jarg1;
4191   arg2 = (Dali::Vector2 *)jarg2;
4192   if (!arg2) {
4193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4194     return 0;
4195   }
4196   {
4197     try {
4198       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4199     } catch (std::out_of_range& e) {
4200       {
4201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4202       };
4203     } catch (std::exception& e) {
4204       {
4205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4206       };
4207     } catch (...) {
4208       {
4209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4210       };
4211     }
4212   }
4213   jresult = (void *)result;
4214   return jresult;
4215 }
4216
4217
4218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4219   void * jresult ;
4220   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4221   Dali::Vector2 *arg2 = 0 ;
4222   Dali::Vector2 result;
4223
4224   arg1 = (Dali::Vector2 *)jarg1;
4225   arg2 = (Dali::Vector2 *)jarg2;
4226   if (!arg2) {
4227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4228     return 0;
4229   }
4230   {
4231     try {
4232       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4233     } catch (std::out_of_range& e) {
4234       {
4235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4236       };
4237     } catch (std::exception& e) {
4238       {
4239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4240       };
4241     } catch (...) {
4242       {
4243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4244       };
4245     }
4246   }
4247   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4248   return jresult;
4249 }
4250
4251
4252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4253   void * jresult ;
4254   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4255   float arg2 ;
4256   Dali::Vector2 result;
4257
4258   arg1 = (Dali::Vector2 *)jarg1;
4259   arg2 = (float)jarg2;
4260   {
4261     try {
4262       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4263     } catch (std::out_of_range& e) {
4264       {
4265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4266       };
4267     } catch (std::exception& e) {
4268       {
4269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4270       };
4271     } catch (...) {
4272       {
4273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4274       };
4275     }
4276   }
4277   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4278   return jresult;
4279 }
4280
4281
4282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4283   void * jresult ;
4284   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4285   Dali::Vector2 *arg2 = 0 ;
4286   Dali::Vector2 *result = 0 ;
4287
4288   arg1 = (Dali::Vector2 *)jarg1;
4289   arg2 = (Dali::Vector2 *)jarg2;
4290   if (!arg2) {
4291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4292     return 0;
4293   }
4294   {
4295     try {
4296       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4297     } catch (std::out_of_range& e) {
4298       {
4299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4300       };
4301     } catch (std::exception& e) {
4302       {
4303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4304       };
4305     } catch (...) {
4306       {
4307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4308       };
4309     }
4310   }
4311   jresult = (void *)result;
4312   return jresult;
4313 }
4314
4315
4316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4317   void * jresult ;
4318   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4319   float arg2 ;
4320   Dali::Vector2 *result = 0 ;
4321
4322   arg1 = (Dali::Vector2 *)jarg1;
4323   arg2 = (float)jarg2;
4324   {
4325     try {
4326       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4327     } catch (std::out_of_range& e) {
4328       {
4329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4330       };
4331     } catch (std::exception& e) {
4332       {
4333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4334       };
4335     } catch (...) {
4336       {
4337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4338       };
4339     }
4340   }
4341   jresult = (void *)result;
4342   return jresult;
4343 }
4344
4345
4346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4347   void * jresult ;
4348   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4349   Dali::Vector2 *arg2 = 0 ;
4350   Dali::Vector2 result;
4351
4352   arg1 = (Dali::Vector2 *)jarg1;
4353   arg2 = (Dali::Vector2 *)jarg2;
4354   if (!arg2) {
4355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4356     return 0;
4357   }
4358   {
4359     try {
4360       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4361     } catch (std::out_of_range& e) {
4362       {
4363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4364       };
4365     } catch (std::exception& e) {
4366       {
4367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4368       };
4369     } catch (...) {
4370       {
4371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4372       };
4373     }
4374   }
4375   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4376   return jresult;
4377 }
4378
4379
4380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4381   void * jresult ;
4382   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4383   float arg2 ;
4384   Dali::Vector2 result;
4385
4386   arg1 = (Dali::Vector2 *)jarg1;
4387   arg2 = (float)jarg2;
4388   {
4389     try {
4390       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4391     } catch (std::out_of_range& e) {
4392       {
4393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4394       };
4395     } catch (std::exception& e) {
4396       {
4397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4398       };
4399     } catch (...) {
4400       {
4401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4402       };
4403     }
4404   }
4405   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4406   return jresult;
4407 }
4408
4409
4410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4411   void * jresult ;
4412   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4413   Dali::Vector2 *arg2 = 0 ;
4414   Dali::Vector2 *result = 0 ;
4415
4416   arg1 = (Dali::Vector2 *)jarg1;
4417   arg2 = (Dali::Vector2 *)jarg2;
4418   if (!arg2) {
4419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4420     return 0;
4421   }
4422   {
4423     try {
4424       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4425     } catch (std::out_of_range& e) {
4426       {
4427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4428       };
4429     } catch (std::exception& e) {
4430       {
4431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4432       };
4433     } catch (...) {
4434       {
4435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4436       };
4437     }
4438   }
4439   jresult = (void *)result;
4440   return jresult;
4441 }
4442
4443
4444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4445   void * jresult ;
4446   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4447   float arg2 ;
4448   Dali::Vector2 *result = 0 ;
4449
4450   arg1 = (Dali::Vector2 *)jarg1;
4451   arg2 = (float)jarg2;
4452   {
4453     try {
4454       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4455     } catch (std::out_of_range& e) {
4456       {
4457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4458       };
4459     } catch (std::exception& e) {
4460       {
4461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4462       };
4463     } catch (...) {
4464       {
4465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4466       };
4467     }
4468   }
4469   jresult = (void *)result;
4470   return jresult;
4471 }
4472
4473
4474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4475   void * jresult ;
4476   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4477   Dali::Vector2 result;
4478
4479   arg1 = (Dali::Vector2 *)jarg1;
4480   {
4481     try {
4482       result = ((Dali::Vector2 const *)arg1)->operator -();
4483     } catch (std::out_of_range& e) {
4484       {
4485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4486       };
4487     } catch (std::exception& e) {
4488       {
4489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4490       };
4491     } catch (...) {
4492       {
4493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4494       };
4495     }
4496   }
4497   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4498   return jresult;
4499 }
4500
4501
4502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4503   unsigned int jresult ;
4504   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4505   Dali::Vector2 *arg2 = 0 ;
4506   bool result;
4507
4508   arg1 = (Dali::Vector2 *)jarg1;
4509   arg2 = (Dali::Vector2 *)jarg2;
4510   if (!arg2) {
4511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4512     return 0;
4513   }
4514   {
4515     try {
4516       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4517     } catch (std::out_of_range& e) {
4518       {
4519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4520       };
4521     } catch (std::exception& e) {
4522       {
4523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4524       };
4525     } catch (...) {
4526       {
4527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4528       };
4529     }
4530   }
4531   jresult = result;
4532   return jresult;
4533 }
4534
4535
4536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4537   unsigned int jresult ;
4538   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4539   Dali::Vector2 *arg2 = 0 ;
4540   bool result;
4541
4542   arg1 = (Dali::Vector2 *)jarg1;
4543   arg2 = (Dali::Vector2 *)jarg2;
4544   if (!arg2) {
4545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4546     return 0;
4547   }
4548   {
4549     try {
4550       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4551     } catch (std::out_of_range& e) {
4552       {
4553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4554       };
4555     } catch (std::exception& e) {
4556       {
4557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4558       };
4559     } catch (...) {
4560       {
4561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4562       };
4563     }
4564   }
4565   jresult = result;
4566   return jresult;
4567 }
4568
4569
4570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4571   float jresult ;
4572   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4573   unsigned int arg2 ;
4574   float *result = 0 ;
4575
4576   arg1 = (Dali::Vector2 *)jarg1;
4577   arg2 = (unsigned int)jarg2;
4578   {
4579     try {
4580       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4581     } catch (std::out_of_range& e) {
4582       {
4583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4584       };
4585     } catch (std::exception& e) {
4586       {
4587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4588       };
4589     } catch (...) {
4590       {
4591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4592       };
4593     }
4594   }
4595   jresult = *result;
4596   return jresult;
4597 }
4598
4599
4600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4601   float jresult ;
4602   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4603   float result;
4604
4605   arg1 = (Dali::Vector2 *)jarg1;
4606   {
4607     try {
4608       result = (float)((Dali::Vector2 const *)arg1)->Length();
4609     } catch (std::out_of_range& e) {
4610       {
4611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4612       };
4613     } catch (std::exception& e) {
4614       {
4615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4616       };
4617     } catch (...) {
4618       {
4619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4620       };
4621     }
4622   }
4623   jresult = result;
4624   return jresult;
4625 }
4626
4627
4628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4629   float jresult ;
4630   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4631   float result;
4632
4633   arg1 = (Dali::Vector2 *)jarg1;
4634   {
4635     try {
4636       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4637     } catch (std::out_of_range& e) {
4638       {
4639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4640       };
4641     } catch (std::exception& e) {
4642       {
4643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4644       };
4645     } catch (...) {
4646       {
4647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4648       };
4649     }
4650   }
4651   jresult = result;
4652   return jresult;
4653 }
4654
4655
4656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4657   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4658
4659   arg1 = (Dali::Vector2 *)jarg1;
4660   {
4661     try {
4662       (arg1)->Normalize();
4663     } catch (std::out_of_range& e) {
4664       {
4665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4666       };
4667     } catch (std::exception& e) {
4668       {
4669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4670       };
4671     } catch (...) {
4672       {
4673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4674       };
4675     }
4676   }
4677 }
4678
4679
4680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4681   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4682   Dali::Vector2 *arg2 = 0 ;
4683   Dali::Vector2 *arg3 = 0 ;
4684
4685   arg1 = (Dali::Vector2 *)jarg1;
4686   arg2 = (Dali::Vector2 *)jarg2;
4687   if (!arg2) {
4688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4689     return ;
4690   }
4691   arg3 = (Dali::Vector2 *)jarg3;
4692   if (!arg3) {
4693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4694     return ;
4695   }
4696   {
4697     try {
4698       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4699     } catch (std::out_of_range& e) {
4700       {
4701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4702       };
4703     } catch (std::exception& e) {
4704       {
4705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4706       };
4707     } catch (...) {
4708       {
4709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4710       };
4711     }
4712   }
4713 }
4714
4715
4716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4717   void * jresult ;
4718   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4719   float *result = 0 ;
4720
4721   arg1 = (Dali::Vector2 *)jarg1;
4722   {
4723     try {
4724       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4725     } catch (std::out_of_range& e) {
4726       {
4727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4728       };
4729     } catch (std::exception& e) {
4730       {
4731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4732       };
4733     } catch (...) {
4734       {
4735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4736       };
4737     }
4738   }
4739   jresult = (void *)result;
4740   return jresult;
4741 }
4742
4743
4744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4745   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4746   float arg2 ;
4747
4748   arg1 = (Dali::Vector2 *)jarg1;
4749   arg2 = (float)jarg2;
4750   if (arg1) (arg1)->x = arg2;
4751 }
4752
4753
4754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4755   float jresult ;
4756   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4757   float result;
4758
4759   arg1 = (Dali::Vector2 *)jarg1;
4760   result = (float) ((arg1)->x);
4761   jresult = result;
4762   return jresult;
4763 }
4764
4765
4766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4767   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4768   float arg2 ;
4769
4770   arg1 = (Dali::Vector2 *)jarg1;
4771   arg2 = (float)jarg2;
4772   if (arg1) (arg1)->width = arg2;
4773 }
4774
4775
4776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4777   float jresult ;
4778   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4779   float result;
4780
4781   arg1 = (Dali::Vector2 *)jarg1;
4782   result = (float) ((arg1)->width);
4783   jresult = result;
4784   return jresult;
4785 }
4786
4787
4788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4789   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4790   float arg2 ;
4791
4792   arg1 = (Dali::Vector2 *)jarg1;
4793   arg2 = (float)jarg2;
4794   if (arg1) (arg1)->y = arg2;
4795 }
4796
4797
4798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4799   float jresult ;
4800   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4801   float result;
4802
4803   arg1 = (Dali::Vector2 *)jarg1;
4804   result = (float) ((arg1)->y);
4805   jresult = result;
4806   return jresult;
4807 }
4808
4809
4810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4811   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4812   float arg2 ;
4813
4814   arg1 = (Dali::Vector2 *)jarg1;
4815   arg2 = (float)jarg2;
4816   if (arg1) (arg1)->height = arg2;
4817 }
4818
4819
4820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4821   float jresult ;
4822   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4823   float result;
4824
4825   arg1 = (Dali::Vector2 *)jarg1;
4826   result = (float) ((arg1)->height);
4827   jresult = result;
4828   return jresult;
4829 }
4830
4831
4832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4834
4835   arg1 = (Dali::Vector2 *)jarg1;
4836   {
4837     try {
4838       delete arg1;
4839     } catch (std::out_of_range& e) {
4840       {
4841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4842       };
4843     } catch (std::exception& e) {
4844       {
4845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4846       };
4847     } catch (...) {
4848       {
4849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4850       };
4851     }
4852   }
4853 }
4854
4855
4856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4857   void * jresult ;
4858   Dali::Vector2 *arg1 = 0 ;
4859   Dali::Vector2 *arg2 = 0 ;
4860   Dali::Vector2 result;
4861
4862   arg1 = (Dali::Vector2 *)jarg1;
4863   if (!arg1) {
4864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4865     return 0;
4866   }
4867   arg2 = (Dali::Vector2 *)jarg2;
4868   if (!arg2) {
4869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4870     return 0;
4871   }
4872   {
4873     try {
4874       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4875     } catch (std::out_of_range& e) {
4876       {
4877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4878       };
4879     } catch (std::exception& e) {
4880       {
4881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4882       };
4883     } catch (...) {
4884       {
4885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4886       };
4887     }
4888   }
4889   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4890   return jresult;
4891 }
4892
4893
4894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4895   void * jresult ;
4896   Dali::Vector2 *arg1 = 0 ;
4897   Dali::Vector2 *arg2 = 0 ;
4898   Dali::Vector2 result;
4899
4900   arg1 = (Dali::Vector2 *)jarg1;
4901   if (!arg1) {
4902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4903     return 0;
4904   }
4905   arg2 = (Dali::Vector2 *)jarg2;
4906   if (!arg2) {
4907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4908     return 0;
4909   }
4910   {
4911     try {
4912       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4913     } catch (std::out_of_range& e) {
4914       {
4915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4916       };
4917     } catch (std::exception& e) {
4918       {
4919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4920       };
4921     } catch (...) {
4922       {
4923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4924       };
4925     }
4926   }
4927   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4928   return jresult;
4929 }
4930
4931
4932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4933   void * jresult ;
4934   Dali::Vector2 *arg1 = 0 ;
4935   float *arg2 = 0 ;
4936   float *arg3 = 0 ;
4937   float temp2 ;
4938   float temp3 ;
4939   Dali::Vector2 result;
4940
4941   arg1 = (Dali::Vector2 *)jarg1;
4942   if (!arg1) {
4943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4944     return 0;
4945   }
4946   temp2 = (float)jarg2;
4947   arg2 = &temp2;
4948   temp3 = (float)jarg3;
4949   arg3 = &temp3;
4950   {
4951     try {
4952       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4953     } catch (std::out_of_range& e) {
4954       {
4955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4956       };
4957     } catch (std::exception& e) {
4958       {
4959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4960       };
4961     } catch (...) {
4962       {
4963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4964       };
4965     }
4966   }
4967   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4968   return jresult;
4969 }
4970
4971
4972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4973   void * jresult ;
4974   Dali::Vector3 *result = 0 ;
4975
4976   {
4977     try {
4978       result = (Dali::Vector3 *)new Dali::Vector3();
4979     } catch (std::out_of_range& e) {
4980       {
4981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4982       };
4983     } catch (std::exception& e) {
4984       {
4985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4986       };
4987     } catch (...) {
4988       {
4989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4990       };
4991     }
4992   }
4993   jresult = (void *)result;
4994   return jresult;
4995 }
4996
4997
4998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4999   void * jresult ;
5000   float arg1 ;
5001   float arg2 ;
5002   float arg3 ;
5003   Dali::Vector3 *result = 0 ;
5004
5005   arg1 = (float)jarg1;
5006   arg2 = (float)jarg2;
5007   arg3 = (float)jarg3;
5008   {
5009     try {
5010       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5011     } catch (std::out_of_range& e) {
5012       {
5013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5014       };
5015     } catch (std::exception& e) {
5016       {
5017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5018       };
5019     } catch (...) {
5020       {
5021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5022       };
5023     }
5024   }
5025   jresult = (void *)result;
5026   return jresult;
5027 }
5028
5029
5030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5031   void * jresult ;
5032   float *arg1 = (float *) 0 ;
5033   Dali::Vector3 *result = 0 ;
5034
5035   arg1 = jarg1;
5036   {
5037     try {
5038       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5039     } catch (std::out_of_range& e) {
5040       {
5041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5042       };
5043     } catch (std::exception& e) {
5044       {
5045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5046       };
5047     } catch (...) {
5048       {
5049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5050       };
5051     }
5052   }
5053   jresult = (void *)result;
5054
5055
5056   return jresult;
5057 }
5058
5059
5060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5061   void * jresult ;
5062   Dali::Vector2 *arg1 = 0 ;
5063   Dali::Vector3 *result = 0 ;
5064
5065   arg1 = (Dali::Vector2 *)jarg1;
5066   if (!arg1) {
5067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5068     return 0;
5069   }
5070   {
5071     try {
5072       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5073     } catch (std::out_of_range& e) {
5074       {
5075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5076       };
5077     } catch (std::exception& e) {
5078       {
5079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5080       };
5081     } catch (...) {
5082       {
5083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5084       };
5085     }
5086   }
5087   jresult = (void *)result;
5088   return jresult;
5089 }
5090
5091
5092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5093   void * jresult ;
5094   Dali::Vector4 *arg1 = 0 ;
5095   Dali::Vector3 *result = 0 ;
5096
5097   arg1 = (Dali::Vector4 *)jarg1;
5098   if (!arg1) {
5099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5100     return 0;
5101   }
5102   {
5103     try {
5104       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5105     } catch (std::out_of_range& e) {
5106       {
5107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5108       };
5109     } catch (std::exception& e) {
5110       {
5111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5112       };
5113     } catch (...) {
5114       {
5115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5116       };
5117     }
5118   }
5119   jresult = (void *)result;
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5125   void * jresult ;
5126   Dali::Vector3 *result = 0 ;
5127
5128   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5129   jresult = (void *)result;
5130   return jresult;
5131 }
5132
5133
5134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5135   void * jresult ;
5136   Dali::Vector3 *result = 0 ;
5137
5138   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5139   jresult = (void *)result;
5140   return jresult;
5141 }
5142
5143
5144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5145   void * jresult ;
5146   Dali::Vector3 *result = 0 ;
5147
5148   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5149   jresult = (void *)result;
5150   return jresult;
5151 }
5152
5153
5154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5155   void * jresult ;
5156   Dali::Vector3 *result = 0 ;
5157
5158   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5159   jresult = (void *)result;
5160   return jresult;
5161 }
5162
5163
5164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5165   void * jresult ;
5166   Dali::Vector3 *result = 0 ;
5167
5168   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5169   jresult = (void *)result;
5170   return jresult;
5171 }
5172
5173
5174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5175   void * jresult ;
5176   Dali::Vector3 *result = 0 ;
5177
5178   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5179   jresult = (void *)result;
5180   return jresult;
5181 }
5182
5183
5184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5185   void * jresult ;
5186   Dali::Vector3 *result = 0 ;
5187
5188   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5189   jresult = (void *)result;
5190   return jresult;
5191 }
5192
5193
5194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5195   void * jresult ;
5196   Dali::Vector3 *result = 0 ;
5197
5198   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5199   jresult = (void *)result;
5200   return jresult;
5201 }
5202
5203
5204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5205   void * jresult ;
5206   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5207   float *arg2 = (float *) 0 ;
5208   Dali::Vector3 *result = 0 ;
5209
5210   arg1 = (Dali::Vector3 *)jarg1;
5211   arg2 = jarg2;
5212   {
5213     try {
5214       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5215     } catch (std::out_of_range& e) {
5216       {
5217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5218       };
5219     } catch (std::exception& e) {
5220       {
5221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5222       };
5223     } catch (...) {
5224       {
5225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5226       };
5227     }
5228   }
5229   jresult = (void *)result;
5230
5231
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5237   void * jresult ;
5238   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5239   Dali::Vector2 *arg2 = 0 ;
5240   Dali::Vector3 *result = 0 ;
5241
5242   arg1 = (Dali::Vector3 *)jarg1;
5243   arg2 = (Dali::Vector2 *)jarg2;
5244   if (!arg2) {
5245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5246     return 0;
5247   }
5248   {
5249     try {
5250       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5251     } catch (std::out_of_range& e) {
5252       {
5253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5254       };
5255     } catch (std::exception& e) {
5256       {
5257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5258       };
5259     } catch (...) {
5260       {
5261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5262       };
5263     }
5264   }
5265   jresult = (void *)result;
5266   return jresult;
5267 }
5268
5269
5270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5271   void * jresult ;
5272   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5273   Dali::Vector4 *arg2 = 0 ;
5274   Dali::Vector3 *result = 0 ;
5275
5276   arg1 = (Dali::Vector3 *)jarg1;
5277   arg2 = (Dali::Vector4 *)jarg2;
5278   if (!arg2) {
5279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5280     return 0;
5281   }
5282   {
5283     try {
5284       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5285     } catch (std::out_of_range& e) {
5286       {
5287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5288       };
5289     } catch (std::exception& e) {
5290       {
5291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5292       };
5293     } catch (...) {
5294       {
5295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5296       };
5297     }
5298   }
5299   jresult = (void *)result;
5300   return jresult;
5301 }
5302
5303
5304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5305   void * jresult ;
5306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5307   Dali::Vector3 *arg2 = 0 ;
5308   Dali::Vector3 result;
5309
5310   arg1 = (Dali::Vector3 *)jarg1;
5311   arg2 = (Dali::Vector3 *)jarg2;
5312   if (!arg2) {
5313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5314     return 0;
5315   }
5316   {
5317     try {
5318       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5319     } catch (std::out_of_range& e) {
5320       {
5321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5322       };
5323     } catch (std::exception& e) {
5324       {
5325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5326       };
5327     } catch (...) {
5328       {
5329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5330       };
5331     }
5332   }
5333   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5334   return jresult;
5335 }
5336
5337
5338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5339   void * jresult ;
5340   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5341   Dali::Vector3 *arg2 = 0 ;
5342   Dali::Vector3 *result = 0 ;
5343
5344   arg1 = (Dali::Vector3 *)jarg1;
5345   arg2 = (Dali::Vector3 *)jarg2;
5346   if (!arg2) {
5347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5348     return 0;
5349   }
5350   {
5351     try {
5352       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5353     } catch (std::out_of_range& e) {
5354       {
5355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5356       };
5357     } catch (std::exception& e) {
5358       {
5359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5360       };
5361     } catch (...) {
5362       {
5363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5364       };
5365     }
5366   }
5367   jresult = (void *)result;
5368   return jresult;
5369 }
5370
5371
5372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5373   void * jresult ;
5374   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5375   Dali::Vector3 *arg2 = 0 ;
5376   Dali::Vector3 result;
5377
5378   arg1 = (Dali::Vector3 *)jarg1;
5379   arg2 = (Dali::Vector3 *)jarg2;
5380   if (!arg2) {
5381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5382     return 0;
5383   }
5384   {
5385     try {
5386       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5387     } catch (std::out_of_range& e) {
5388       {
5389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5390       };
5391     } catch (std::exception& e) {
5392       {
5393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5394       };
5395     } catch (...) {
5396       {
5397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5398       };
5399     }
5400   }
5401   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5402   return jresult;
5403 }
5404
5405
5406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5407   void * jresult ;
5408   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5409   Dali::Vector3 *arg2 = 0 ;
5410   Dali::Vector3 *result = 0 ;
5411
5412   arg1 = (Dali::Vector3 *)jarg1;
5413   arg2 = (Dali::Vector3 *)jarg2;
5414   if (!arg2) {
5415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5416     return 0;
5417   }
5418   {
5419     try {
5420       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5421     } catch (std::out_of_range& e) {
5422       {
5423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5424       };
5425     } catch (std::exception& e) {
5426       {
5427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5428       };
5429     } catch (...) {
5430       {
5431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5432       };
5433     }
5434   }
5435   jresult = (void *)result;
5436   return jresult;
5437 }
5438
5439
5440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5441   void * jresult ;
5442   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5443   Dali::Vector3 *arg2 = 0 ;
5444   Dali::Vector3 result;
5445
5446   arg1 = (Dali::Vector3 *)jarg1;
5447   arg2 = (Dali::Vector3 *)jarg2;
5448   if (!arg2) {
5449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5450     return 0;
5451   }
5452   {
5453     try {
5454       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5455     } catch (std::out_of_range& e) {
5456       {
5457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5458       };
5459     } catch (std::exception& e) {
5460       {
5461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5462       };
5463     } catch (...) {
5464       {
5465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5466       };
5467     }
5468   }
5469   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5470   return jresult;
5471 }
5472
5473
5474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5475   void * jresult ;
5476   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5477   float arg2 ;
5478   Dali::Vector3 result;
5479
5480   arg1 = (Dali::Vector3 *)jarg1;
5481   arg2 = (float)jarg2;
5482   {
5483     try {
5484       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5485     } catch (std::out_of_range& e) {
5486       {
5487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5488       };
5489     } catch (std::exception& e) {
5490       {
5491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5492       };
5493     } catch (...) {
5494       {
5495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5496       };
5497     }
5498   }
5499   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5500   return jresult;
5501 }
5502
5503
5504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5505   void * jresult ;
5506   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5507   Dali::Vector3 *arg2 = 0 ;
5508   Dali::Vector3 *result = 0 ;
5509
5510   arg1 = (Dali::Vector3 *)jarg1;
5511   arg2 = (Dali::Vector3 *)jarg2;
5512   if (!arg2) {
5513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5514     return 0;
5515   }
5516   {
5517     try {
5518       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5519     } catch (std::out_of_range& e) {
5520       {
5521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5522       };
5523     } catch (std::exception& e) {
5524       {
5525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5526       };
5527     } catch (...) {
5528       {
5529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5530       };
5531     }
5532   }
5533   jresult = (void *)result;
5534   return jresult;
5535 }
5536
5537
5538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5539   void * jresult ;
5540   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5541   float arg2 ;
5542   Dali::Vector3 *result = 0 ;
5543
5544   arg1 = (Dali::Vector3 *)jarg1;
5545   arg2 = (float)jarg2;
5546   {
5547     try {
5548       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5549     } catch (std::out_of_range& e) {
5550       {
5551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5552       };
5553     } catch (std::exception& e) {
5554       {
5555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5556       };
5557     } catch (...) {
5558       {
5559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5560       };
5561     }
5562   }
5563   jresult = (void *)result;
5564   return jresult;
5565 }
5566
5567
5568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5569   void * jresult ;
5570   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5571   Dali::Quaternion *arg2 = 0 ;
5572   Dali::Vector3 *result = 0 ;
5573
5574   arg1 = (Dali::Vector3 *)jarg1;
5575   arg2 = (Dali::Quaternion *)jarg2;
5576   if (!arg2) {
5577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5578     return 0;
5579   }
5580   {
5581     try {
5582       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5583     } catch (std::out_of_range& e) {
5584       {
5585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5586       };
5587     } catch (std::exception& e) {
5588       {
5589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5590       };
5591     } catch (...) {
5592       {
5593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5594       };
5595     }
5596   }
5597   jresult = (void *)result;
5598   return jresult;
5599 }
5600
5601
5602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5603   void * jresult ;
5604   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5605   Dali::Vector3 *arg2 = 0 ;
5606   Dali::Vector3 result;
5607
5608   arg1 = (Dali::Vector3 *)jarg1;
5609   arg2 = (Dali::Vector3 *)jarg2;
5610   if (!arg2) {
5611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5612     return 0;
5613   }
5614   {
5615     try {
5616       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5617     } catch (std::out_of_range& e) {
5618       {
5619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5620       };
5621     } catch (std::exception& e) {
5622       {
5623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5624       };
5625     } catch (...) {
5626       {
5627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5628       };
5629     }
5630   }
5631   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5632   return jresult;
5633 }
5634
5635
5636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5637   void * jresult ;
5638   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5639   float arg2 ;
5640   Dali::Vector3 result;
5641
5642   arg1 = (Dali::Vector3 *)jarg1;
5643   arg2 = (float)jarg2;
5644   {
5645     try {
5646       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5647     } catch (std::out_of_range& e) {
5648       {
5649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5650       };
5651     } catch (std::exception& e) {
5652       {
5653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5654       };
5655     } catch (...) {
5656       {
5657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5658       };
5659     }
5660   }
5661   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5662   return jresult;
5663 }
5664
5665
5666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5667   void * jresult ;
5668   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5669   Dali::Vector3 *arg2 = 0 ;
5670   Dali::Vector3 *result = 0 ;
5671
5672   arg1 = (Dali::Vector3 *)jarg1;
5673   arg2 = (Dali::Vector3 *)jarg2;
5674   if (!arg2) {
5675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5676     return 0;
5677   }
5678   {
5679     try {
5680       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5681     } catch (std::out_of_range& e) {
5682       {
5683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5684       };
5685     } catch (std::exception& e) {
5686       {
5687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5688       };
5689     } catch (...) {
5690       {
5691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5692       };
5693     }
5694   }
5695   jresult = (void *)result;
5696   return jresult;
5697 }
5698
5699
5700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5701   void * jresult ;
5702   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5703   float arg2 ;
5704   Dali::Vector3 *result = 0 ;
5705
5706   arg1 = (Dali::Vector3 *)jarg1;
5707   arg2 = (float)jarg2;
5708   {
5709     try {
5710       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5711     } catch (std::out_of_range& e) {
5712       {
5713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5714       };
5715     } catch (std::exception& e) {
5716       {
5717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5718       };
5719     } catch (...) {
5720       {
5721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5722       };
5723     }
5724   }
5725   jresult = (void *)result;
5726   return jresult;
5727 }
5728
5729
5730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5731   void * jresult ;
5732   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5733   Dali::Vector3 result;
5734
5735   arg1 = (Dali::Vector3 *)jarg1;
5736   {
5737     try {
5738       result = ((Dali::Vector3 const *)arg1)->operator -();
5739     } catch (std::out_of_range& e) {
5740       {
5741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5742       };
5743     } catch (std::exception& e) {
5744       {
5745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (...) {
5748       {
5749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5750       };
5751     }
5752   }
5753   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5754   return jresult;
5755 }
5756
5757
5758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5759   unsigned int jresult ;
5760   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5761   Dali::Vector3 *arg2 = 0 ;
5762   bool result;
5763
5764   arg1 = (Dali::Vector3 *)jarg1;
5765   arg2 = (Dali::Vector3 *)jarg2;
5766   if (!arg2) {
5767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5768     return 0;
5769   }
5770   {
5771     try {
5772       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5773     } catch (std::out_of_range& e) {
5774       {
5775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5776       };
5777     } catch (std::exception& e) {
5778       {
5779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5780       };
5781     } catch (...) {
5782       {
5783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5784       };
5785     }
5786   }
5787   jresult = result;
5788   return jresult;
5789 }
5790
5791
5792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5793   unsigned int jresult ;
5794   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5795   Dali::Vector3 *arg2 = 0 ;
5796   bool result;
5797
5798   arg1 = (Dali::Vector3 *)jarg1;
5799   arg2 = (Dali::Vector3 *)jarg2;
5800   if (!arg2) {
5801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5802     return 0;
5803   }
5804   {
5805     try {
5806       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5807     } catch (std::out_of_range& e) {
5808       {
5809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5810       };
5811     } catch (std::exception& e) {
5812       {
5813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5814       };
5815     } catch (...) {
5816       {
5817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5818       };
5819     }
5820   }
5821   jresult = result;
5822   return jresult;
5823 }
5824
5825
5826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5827   float jresult ;
5828   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5829   unsigned int arg2 ;
5830   float *result = 0 ;
5831
5832   arg1 = (Dali::Vector3 *)jarg1;
5833   arg2 = (unsigned int)jarg2;
5834   {
5835     try {
5836       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5837     } catch (std::out_of_range& e) {
5838       {
5839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5840       };
5841     } catch (std::exception& e) {
5842       {
5843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5844       };
5845     } catch (...) {
5846       {
5847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5848       };
5849     }
5850   }
5851   jresult = *result;
5852   return jresult;
5853 }
5854
5855
5856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5857   float jresult ;
5858   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5859   Dali::Vector3 *arg2 = 0 ;
5860   float result;
5861
5862   arg1 = (Dali::Vector3 *)jarg1;
5863   arg2 = (Dali::Vector3 *)jarg2;
5864   if (!arg2) {
5865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5866     return 0;
5867   }
5868   {
5869     try {
5870       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5871     } catch (std::out_of_range& e) {
5872       {
5873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5874       };
5875     } catch (std::exception& e) {
5876       {
5877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5878       };
5879     } catch (...) {
5880       {
5881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5882       };
5883     }
5884   }
5885   jresult = result;
5886   return jresult;
5887 }
5888
5889
5890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5891   void * jresult ;
5892   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5893   Dali::Vector3 *arg2 = 0 ;
5894   Dali::Vector3 result;
5895
5896   arg1 = (Dali::Vector3 *)jarg1;
5897   arg2 = (Dali::Vector3 *)jarg2;
5898   if (!arg2) {
5899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5900     return 0;
5901   }
5902   {
5903     try {
5904       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5905     } catch (std::out_of_range& e) {
5906       {
5907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5908       };
5909     } catch (std::exception& e) {
5910       {
5911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5912       };
5913     } catch (...) {
5914       {
5915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5916       };
5917     }
5918   }
5919   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5920   return jresult;
5921 }
5922
5923
5924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5925   float jresult ;
5926   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5927   float result;
5928
5929   arg1 = (Dali::Vector3 *)jarg1;
5930   {
5931     try {
5932       result = (float)((Dali::Vector3 const *)arg1)->Length();
5933     } catch (std::out_of_range& e) {
5934       {
5935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5936       };
5937     } catch (std::exception& e) {
5938       {
5939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (...) {
5942       {
5943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5944       };
5945     }
5946   }
5947   jresult = result;
5948   return jresult;
5949 }
5950
5951
5952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5953   float jresult ;
5954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5955   float result;
5956
5957   arg1 = (Dali::Vector3 *)jarg1;
5958   {
5959     try {
5960       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5961     } catch (std::out_of_range& e) {
5962       {
5963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5964       };
5965     } catch (std::exception& e) {
5966       {
5967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5968       };
5969     } catch (...) {
5970       {
5971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5972       };
5973     }
5974   }
5975   jresult = result;
5976   return jresult;
5977 }
5978
5979
5980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
5981   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5982
5983   arg1 = (Dali::Vector3 *)jarg1;
5984   {
5985     try {
5986       (arg1)->Normalize();
5987     } catch (std::out_of_range& e) {
5988       {
5989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5990       };
5991     } catch (std::exception& e) {
5992       {
5993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5994       };
5995     } catch (...) {
5996       {
5997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5998       };
5999     }
6000   }
6001 }
6002
6003
6004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6005   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6006   Dali::Vector3 *arg2 = 0 ;
6007   Dali::Vector3 *arg3 = 0 ;
6008
6009   arg1 = (Dali::Vector3 *)jarg1;
6010   arg2 = (Dali::Vector3 *)jarg2;
6011   if (!arg2) {
6012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6013     return ;
6014   }
6015   arg3 = (Dali::Vector3 *)jarg3;
6016   if (!arg3) {
6017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6018     return ;
6019   }
6020   {
6021     try {
6022       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6023     } catch (std::out_of_range& e) {
6024       {
6025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6026       };
6027     } catch (std::exception& e) {
6028       {
6029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6030       };
6031     } catch (...) {
6032       {
6033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6034       };
6035     }
6036   }
6037 }
6038
6039
6040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6041   void * jresult ;
6042   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6043   float *result = 0 ;
6044
6045   arg1 = (Dali::Vector3 *)jarg1;
6046   {
6047     try {
6048       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6049     } catch (std::out_of_range& e) {
6050       {
6051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6052       };
6053     } catch (std::exception& e) {
6054       {
6055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6056       };
6057     } catch (...) {
6058       {
6059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6060       };
6061     }
6062   }
6063   jresult = (void *)result;
6064   return jresult;
6065 }
6066
6067
6068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6069   void * jresult ;
6070   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6071   Dali::Vector2 *result = 0 ;
6072
6073   arg1 = (Dali::Vector3 *)jarg1;
6074   {
6075     try {
6076       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6077     } catch (std::out_of_range& e) {
6078       {
6079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6080       };
6081     } catch (std::exception& e) {
6082       {
6083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6084       };
6085     } catch (...) {
6086       {
6087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6088       };
6089     }
6090   }
6091   jresult = (void *)result;
6092   return jresult;
6093 }
6094
6095
6096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6097   void * jresult ;
6098   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6099   Dali::Vector2 *result = 0 ;
6100
6101   arg1 = (Dali::Vector3 *)jarg1;
6102   {
6103     try {
6104       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6105     } catch (std::out_of_range& e) {
6106       {
6107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6108       };
6109     } catch (std::exception& e) {
6110       {
6111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6112       };
6113     } catch (...) {
6114       {
6115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6116       };
6117     }
6118   }
6119   jresult = (void *)result;
6120   return jresult;
6121 }
6122
6123
6124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6125   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6126   float arg2 ;
6127
6128   arg1 = (Dali::Vector3 *)jarg1;
6129   arg2 = (float)jarg2;
6130   if (arg1) (arg1)->x = arg2;
6131 }
6132
6133
6134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6135   float jresult ;
6136   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6137   float result;
6138
6139   arg1 = (Dali::Vector3 *)jarg1;
6140   result = (float) ((arg1)->x);
6141   jresult = result;
6142   return jresult;
6143 }
6144
6145
6146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6147   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6148   float arg2 ;
6149
6150   arg1 = (Dali::Vector3 *)jarg1;
6151   arg2 = (float)jarg2;
6152   if (arg1) (arg1)->width = arg2;
6153 }
6154
6155
6156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6157   float jresult ;
6158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6159   float result;
6160
6161   arg1 = (Dali::Vector3 *)jarg1;
6162   result = (float) ((arg1)->width);
6163   jresult = result;
6164   return jresult;
6165 }
6166
6167
6168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6169   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6170   float arg2 ;
6171
6172   arg1 = (Dali::Vector3 *)jarg1;
6173   arg2 = (float)jarg2;
6174   if (arg1) (arg1)->r = arg2;
6175 }
6176
6177
6178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6179   float jresult ;
6180   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6181   float result;
6182
6183   arg1 = (Dali::Vector3 *)jarg1;
6184   result = (float) ((arg1)->r);
6185   jresult = result;
6186   return jresult;
6187 }
6188
6189
6190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6192   float arg2 ;
6193
6194   arg1 = (Dali::Vector3 *)jarg1;
6195   arg2 = (float)jarg2;
6196   if (arg1) (arg1)->y = arg2;
6197 }
6198
6199
6200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6201   float jresult ;
6202   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6203   float result;
6204
6205   arg1 = (Dali::Vector3 *)jarg1;
6206   result = (float) ((arg1)->y);
6207   jresult = result;
6208   return jresult;
6209 }
6210
6211
6212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6213   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6214   float arg2 ;
6215
6216   arg1 = (Dali::Vector3 *)jarg1;
6217   arg2 = (float)jarg2;
6218   if (arg1) (arg1)->height = arg2;
6219 }
6220
6221
6222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6223   float jresult ;
6224   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6225   float result;
6226
6227   arg1 = (Dali::Vector3 *)jarg1;
6228   result = (float) ((arg1)->height);
6229   jresult = result;
6230   return jresult;
6231 }
6232
6233
6234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6235   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6236   float arg2 ;
6237
6238   arg1 = (Dali::Vector3 *)jarg1;
6239   arg2 = (float)jarg2;
6240   if (arg1) (arg1)->g = arg2;
6241 }
6242
6243
6244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6245   float jresult ;
6246   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6247   float result;
6248
6249   arg1 = (Dali::Vector3 *)jarg1;
6250   result = (float) ((arg1)->g);
6251   jresult = result;
6252   return jresult;
6253 }
6254
6255
6256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6257   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6258   float arg2 ;
6259
6260   arg1 = (Dali::Vector3 *)jarg1;
6261   arg2 = (float)jarg2;
6262   if (arg1) (arg1)->z = arg2;
6263 }
6264
6265
6266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6267   float jresult ;
6268   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6269   float result;
6270
6271   arg1 = (Dali::Vector3 *)jarg1;
6272   result = (float) ((arg1)->z);
6273   jresult = result;
6274   return jresult;
6275 }
6276
6277
6278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6279   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6280   float arg2 ;
6281
6282   arg1 = (Dali::Vector3 *)jarg1;
6283   arg2 = (float)jarg2;
6284   if (arg1) (arg1)->depth = arg2;
6285 }
6286
6287
6288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6289   float jresult ;
6290   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6291   float result;
6292
6293   arg1 = (Dali::Vector3 *)jarg1;
6294   result = (float) ((arg1)->depth);
6295   jresult = result;
6296   return jresult;
6297 }
6298
6299
6300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6301   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6302   float arg2 ;
6303
6304   arg1 = (Dali::Vector3 *)jarg1;
6305   arg2 = (float)jarg2;
6306   if (arg1) (arg1)->b = arg2;
6307 }
6308
6309
6310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6311   float jresult ;
6312   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6313   float result;
6314
6315   arg1 = (Dali::Vector3 *)jarg1;
6316   result = (float) ((arg1)->b);
6317   jresult = result;
6318   return jresult;
6319 }
6320
6321
6322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6323   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6324
6325   arg1 = (Dali::Vector3 *)jarg1;
6326   {
6327     try {
6328       delete arg1;
6329     } catch (std::out_of_range& e) {
6330       {
6331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6332       };
6333     } catch (std::exception& e) {
6334       {
6335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6336       };
6337     } catch (...) {
6338       {
6339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6340       };
6341     }
6342   }
6343 }
6344
6345
6346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6347   void * jresult ;
6348   Dali::Vector3 *arg1 = 0 ;
6349   Dali::Vector3 *arg2 = 0 ;
6350   Dali::Vector3 result;
6351
6352   arg1 = (Dali::Vector3 *)jarg1;
6353   if (!arg1) {
6354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6355     return 0;
6356   }
6357   arg2 = (Dali::Vector3 *)jarg2;
6358   if (!arg2) {
6359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6360     return 0;
6361   }
6362   {
6363     try {
6364       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6365     } catch (std::out_of_range& e) {
6366       {
6367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6368       };
6369     } catch (std::exception& e) {
6370       {
6371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6372       };
6373     } catch (...) {
6374       {
6375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6376       };
6377     }
6378   }
6379   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6380   return jresult;
6381 }
6382
6383
6384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6385   void * jresult ;
6386   Dali::Vector3 *arg1 = 0 ;
6387   Dali::Vector3 *arg2 = 0 ;
6388   Dali::Vector3 result;
6389
6390   arg1 = (Dali::Vector3 *)jarg1;
6391   if (!arg1) {
6392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6393     return 0;
6394   }
6395   arg2 = (Dali::Vector3 *)jarg2;
6396   if (!arg2) {
6397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6398     return 0;
6399   }
6400   {
6401     try {
6402       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6403     } catch (std::out_of_range& e) {
6404       {
6405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6406       };
6407     } catch (std::exception& e) {
6408       {
6409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6410       };
6411     } catch (...) {
6412       {
6413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6414       };
6415     }
6416   }
6417   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6418   return jresult;
6419 }
6420
6421
6422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6423   void * jresult ;
6424   Dali::Vector3 *arg1 = 0 ;
6425   float *arg2 = 0 ;
6426   float *arg3 = 0 ;
6427   float temp2 ;
6428   float temp3 ;
6429   Dali::Vector3 result;
6430
6431   arg1 = (Dali::Vector3 *)jarg1;
6432   if (!arg1) {
6433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6434     return 0;
6435   }
6436   temp2 = (float)jarg2;
6437   arg2 = &temp2;
6438   temp3 = (float)jarg3;
6439   arg3 = &temp3;
6440   {
6441     try {
6442       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6443     } catch (std::out_of_range& e) {
6444       {
6445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6446       };
6447     } catch (std::exception& e) {
6448       {
6449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6450       };
6451     } catch (...) {
6452       {
6453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6454       };
6455     }
6456   }
6457   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6458   return jresult;
6459 }
6460
6461
6462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6463   void * jresult ;
6464   Dali::Vector4 *result = 0 ;
6465
6466   {
6467     try {
6468       result = (Dali::Vector4 *)new Dali::Vector4();
6469     } catch (std::out_of_range& e) {
6470       {
6471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6472       };
6473     } catch (std::exception& e) {
6474       {
6475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6476       };
6477     } catch (...) {
6478       {
6479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6480       };
6481     }
6482   }
6483   jresult = (void *)result;
6484   return jresult;
6485 }
6486
6487
6488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6489   void * jresult ;
6490   float arg1 ;
6491   float arg2 ;
6492   float arg3 ;
6493   float arg4 ;
6494   Dali::Vector4 *result = 0 ;
6495
6496   arg1 = (float)jarg1;
6497   arg2 = (float)jarg2;
6498   arg3 = (float)jarg3;
6499   arg4 = (float)jarg4;
6500   {
6501     try {
6502       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6503     } catch (std::out_of_range& e) {
6504       {
6505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6506       };
6507     } catch (std::exception& e) {
6508       {
6509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6510       };
6511     } catch (...) {
6512       {
6513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6514       };
6515     }
6516   }
6517   jresult = (void *)result;
6518   return jresult;
6519 }
6520
6521
6522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6523   void * jresult ;
6524   float *arg1 = (float *) 0 ;
6525   Dali::Vector4 *result = 0 ;
6526
6527   arg1 = jarg1;
6528   {
6529     try {
6530       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6531     } catch (std::out_of_range& e) {
6532       {
6533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6534       };
6535     } catch (std::exception& e) {
6536       {
6537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (...) {
6540       {
6541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6542       };
6543     }
6544   }
6545   jresult = (void *)result;
6546
6547
6548   return jresult;
6549 }
6550
6551
6552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6553   void * jresult ;
6554   Dali::Vector2 *arg1 = 0 ;
6555   Dali::Vector4 *result = 0 ;
6556
6557   arg1 = (Dali::Vector2 *)jarg1;
6558   if (!arg1) {
6559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6560     return 0;
6561   }
6562   {
6563     try {
6564       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6565     } catch (std::out_of_range& e) {
6566       {
6567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6568       };
6569     } catch (std::exception& e) {
6570       {
6571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6572       };
6573     } catch (...) {
6574       {
6575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6576       };
6577     }
6578   }
6579   jresult = (void *)result;
6580   return jresult;
6581 }
6582
6583
6584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6585   void * jresult ;
6586   Dali::Vector3 *arg1 = 0 ;
6587   Dali::Vector4 *result = 0 ;
6588
6589   arg1 = (Dali::Vector3 *)jarg1;
6590   if (!arg1) {
6591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6592     return 0;
6593   }
6594   {
6595     try {
6596       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6597     } catch (std::out_of_range& e) {
6598       {
6599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6600       };
6601     } catch (std::exception& e) {
6602       {
6603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6604       };
6605     } catch (...) {
6606       {
6607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6608       };
6609     }
6610   }
6611   jresult = (void *)result;
6612   return jresult;
6613 }
6614
6615
6616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6617   void * jresult ;
6618   Dali::Vector4 *result = 0 ;
6619
6620   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6621   jresult = (void *)result;
6622   return jresult;
6623 }
6624
6625
6626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6627   void * jresult ;
6628   Dali::Vector4 *result = 0 ;
6629
6630   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6631   jresult = (void *)result;
6632   return jresult;
6633 }
6634
6635
6636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6637   void * jresult ;
6638   Dali::Vector4 *result = 0 ;
6639
6640   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6641   jresult = (void *)result;
6642   return jresult;
6643 }
6644
6645
6646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6647   void * jresult ;
6648   Dali::Vector4 *result = 0 ;
6649
6650   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6651   jresult = (void *)result;
6652   return jresult;
6653 }
6654
6655
6656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6657   void * jresult ;
6658   Dali::Vector4 *result = 0 ;
6659
6660   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6661   jresult = (void *)result;
6662   return jresult;
6663 }
6664
6665
6666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6667   void * jresult ;
6668   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6669   float *arg2 = (float *) 0 ;
6670   Dali::Vector4 *result = 0 ;
6671
6672   arg1 = (Dali::Vector4 *)jarg1;
6673   arg2 = jarg2;
6674   {
6675     try {
6676       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6677     } catch (std::out_of_range& e) {
6678       {
6679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6680       };
6681     } catch (std::exception& e) {
6682       {
6683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6684       };
6685     } catch (...) {
6686       {
6687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6688       };
6689     }
6690   }
6691   jresult = (void *)result;
6692
6693
6694   return jresult;
6695 }
6696
6697
6698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6699   void * jresult ;
6700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6701   Dali::Vector2 *arg2 = 0 ;
6702   Dali::Vector4 *result = 0 ;
6703
6704   arg1 = (Dali::Vector4 *)jarg1;
6705   arg2 = (Dali::Vector2 *)jarg2;
6706   if (!arg2) {
6707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6708     return 0;
6709   }
6710   {
6711     try {
6712       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6713     } catch (std::out_of_range& e) {
6714       {
6715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6716       };
6717     } catch (std::exception& e) {
6718       {
6719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6720       };
6721     } catch (...) {
6722       {
6723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6724       };
6725     }
6726   }
6727   jresult = (void *)result;
6728   return jresult;
6729 }
6730
6731
6732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6733   void * jresult ;
6734   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6735   Dali::Vector3 *arg2 = 0 ;
6736   Dali::Vector4 *result = 0 ;
6737
6738   arg1 = (Dali::Vector4 *)jarg1;
6739   arg2 = (Dali::Vector3 *)jarg2;
6740   if (!arg2) {
6741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6742     return 0;
6743   }
6744   {
6745     try {
6746       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6747     } catch (std::out_of_range& e) {
6748       {
6749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6750       };
6751     } catch (std::exception& e) {
6752       {
6753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6754       };
6755     } catch (...) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6758       };
6759     }
6760   }
6761   jresult = (void *)result;
6762   return jresult;
6763 }
6764
6765
6766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6767   void * jresult ;
6768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6769   Dali::Vector4 *arg2 = 0 ;
6770   Dali::Vector4 result;
6771
6772   arg1 = (Dali::Vector4 *)jarg1;
6773   arg2 = (Dali::Vector4 *)jarg2;
6774   if (!arg2) {
6775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6776     return 0;
6777   }
6778   {
6779     try {
6780       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6781     } catch (std::out_of_range& e) {
6782       {
6783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6784       };
6785     } catch (std::exception& e) {
6786       {
6787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6788       };
6789     } catch (...) {
6790       {
6791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6792       };
6793     }
6794   }
6795   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6796   return jresult;
6797 }
6798
6799
6800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6801   void * jresult ;
6802   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6803   Dali::Vector4 *arg2 = 0 ;
6804   Dali::Vector4 *result = 0 ;
6805
6806   arg1 = (Dali::Vector4 *)jarg1;
6807   arg2 = (Dali::Vector4 *)jarg2;
6808   if (!arg2) {
6809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6810     return 0;
6811   }
6812   {
6813     try {
6814       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6815     } catch (std::out_of_range& e) {
6816       {
6817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6818       };
6819     } catch (std::exception& e) {
6820       {
6821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6822       };
6823     } catch (...) {
6824       {
6825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6826       };
6827     }
6828   }
6829   jresult = (void *)result;
6830   return jresult;
6831 }
6832
6833
6834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6835   void * jresult ;
6836   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6837   Dali::Vector4 *arg2 = 0 ;
6838   Dali::Vector4 result;
6839
6840   arg1 = (Dali::Vector4 *)jarg1;
6841   arg2 = (Dali::Vector4 *)jarg2;
6842   if (!arg2) {
6843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6844     return 0;
6845   }
6846   {
6847     try {
6848       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6849     } catch (std::out_of_range& e) {
6850       {
6851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6852       };
6853     } catch (std::exception& e) {
6854       {
6855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6856       };
6857     } catch (...) {
6858       {
6859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6860       };
6861     }
6862   }
6863   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6864   return jresult;
6865 }
6866
6867
6868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6869   void * jresult ;
6870   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6871   Dali::Vector4 *arg2 = 0 ;
6872   Dali::Vector4 *result = 0 ;
6873
6874   arg1 = (Dali::Vector4 *)jarg1;
6875   arg2 = (Dali::Vector4 *)jarg2;
6876   if (!arg2) {
6877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6878     return 0;
6879   }
6880   {
6881     try {
6882       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6883     } catch (std::out_of_range& e) {
6884       {
6885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6886       };
6887     } catch (std::exception& e) {
6888       {
6889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6890       };
6891     } catch (...) {
6892       {
6893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6894       };
6895     }
6896   }
6897   jresult = (void *)result;
6898   return jresult;
6899 }
6900
6901
6902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6903   void * jresult ;
6904   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6905   Dali::Vector4 *arg2 = 0 ;
6906   Dali::Vector4 result;
6907
6908   arg1 = (Dali::Vector4 *)jarg1;
6909   arg2 = (Dali::Vector4 *)jarg2;
6910   if (!arg2) {
6911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6912     return 0;
6913   }
6914   {
6915     try {
6916       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6917     } catch (std::out_of_range& e) {
6918       {
6919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6920       };
6921     } catch (std::exception& e) {
6922       {
6923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6924       };
6925     } catch (...) {
6926       {
6927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6928       };
6929     }
6930   }
6931   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6932   return jresult;
6933 }
6934
6935
6936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6937   void * jresult ;
6938   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6939   float arg2 ;
6940   Dali::Vector4 result;
6941
6942   arg1 = (Dali::Vector4 *)jarg1;
6943   arg2 = (float)jarg2;
6944   {
6945     try {
6946       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6947     } catch (std::out_of_range& e) {
6948       {
6949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6950       };
6951     } catch (std::exception& e) {
6952       {
6953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6954       };
6955     } catch (...) {
6956       {
6957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6958       };
6959     }
6960   }
6961   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6962   return jresult;
6963 }
6964
6965
6966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6967   void * jresult ;
6968   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6969   Dali::Vector4 *arg2 = 0 ;
6970   Dali::Vector4 *result = 0 ;
6971
6972   arg1 = (Dali::Vector4 *)jarg1;
6973   arg2 = (Dali::Vector4 *)jarg2;
6974   if (!arg2) {
6975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6976     return 0;
6977   }
6978   {
6979     try {
6980       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6981     } catch (std::out_of_range& e) {
6982       {
6983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6984       };
6985     } catch (std::exception& e) {
6986       {
6987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6988       };
6989     } catch (...) {
6990       {
6991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6992       };
6993     }
6994   }
6995   jresult = (void *)result;
6996   return jresult;
6997 }
6998
6999
7000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7001   void * jresult ;
7002   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7003   float arg2 ;
7004   Dali::Vector4 *result = 0 ;
7005
7006   arg1 = (Dali::Vector4 *)jarg1;
7007   arg2 = (float)jarg2;
7008   {
7009     try {
7010       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7011     } catch (std::out_of_range& e) {
7012       {
7013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7014       };
7015     } catch (std::exception& e) {
7016       {
7017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7018       };
7019     } catch (...) {
7020       {
7021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7022       };
7023     }
7024   }
7025   jresult = (void *)result;
7026   return jresult;
7027 }
7028
7029
7030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7031   void * jresult ;
7032   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7033   Dali::Vector4 *arg2 = 0 ;
7034   Dali::Vector4 result;
7035
7036   arg1 = (Dali::Vector4 *)jarg1;
7037   arg2 = (Dali::Vector4 *)jarg2;
7038   if (!arg2) {
7039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7040     return 0;
7041   }
7042   {
7043     try {
7044       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7045     } catch (std::out_of_range& e) {
7046       {
7047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7048       };
7049     } catch (std::exception& e) {
7050       {
7051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7052       };
7053     } catch (...) {
7054       {
7055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7056       };
7057     }
7058   }
7059   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7060   return jresult;
7061 }
7062
7063
7064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7065   void * jresult ;
7066   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7067   float arg2 ;
7068   Dali::Vector4 result;
7069
7070   arg1 = (Dali::Vector4 *)jarg1;
7071   arg2 = (float)jarg2;
7072   {
7073     try {
7074       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7075     } catch (std::out_of_range& e) {
7076       {
7077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7078       };
7079     } catch (std::exception& e) {
7080       {
7081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7082       };
7083     } catch (...) {
7084       {
7085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7086       };
7087     }
7088   }
7089   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7090   return jresult;
7091 }
7092
7093
7094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7095   void * jresult ;
7096   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7097   Dali::Vector4 *arg2 = 0 ;
7098   Dali::Vector4 *result = 0 ;
7099
7100   arg1 = (Dali::Vector4 *)jarg1;
7101   arg2 = (Dali::Vector4 *)jarg2;
7102   if (!arg2) {
7103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7104     return 0;
7105   }
7106   {
7107     try {
7108       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7109     } catch (std::out_of_range& e) {
7110       {
7111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7112       };
7113     } catch (std::exception& e) {
7114       {
7115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7116       };
7117     } catch (...) {
7118       {
7119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7120       };
7121     }
7122   }
7123   jresult = (void *)result;
7124   return jresult;
7125 }
7126
7127
7128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7129   void * jresult ;
7130   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7131   float arg2 ;
7132   Dali::Vector4 *result = 0 ;
7133
7134   arg1 = (Dali::Vector4 *)jarg1;
7135   arg2 = (float)jarg2;
7136   {
7137     try {
7138       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7139     } catch (std::out_of_range& e) {
7140       {
7141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7142       };
7143     } catch (std::exception& e) {
7144       {
7145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7146       };
7147     } catch (...) {
7148       {
7149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7150       };
7151     }
7152   }
7153   jresult = (void *)result;
7154   return jresult;
7155 }
7156
7157
7158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7159   void * jresult ;
7160   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7161   Dali::Vector4 result;
7162
7163   arg1 = (Dali::Vector4 *)jarg1;
7164   {
7165     try {
7166       result = ((Dali::Vector4 const *)arg1)->operator -();
7167     } catch (std::out_of_range& e) {
7168       {
7169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7170       };
7171     } catch (std::exception& e) {
7172       {
7173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7174       };
7175     } catch (...) {
7176       {
7177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7178       };
7179     }
7180   }
7181   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7182   return jresult;
7183 }
7184
7185
7186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7187   unsigned int jresult ;
7188   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7189   Dali::Vector4 *arg2 = 0 ;
7190   bool result;
7191
7192   arg1 = (Dali::Vector4 *)jarg1;
7193   arg2 = (Dali::Vector4 *)jarg2;
7194   if (!arg2) {
7195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7196     return 0;
7197   }
7198   {
7199     try {
7200       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7201     } catch (std::out_of_range& e) {
7202       {
7203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7204       };
7205     } catch (std::exception& e) {
7206       {
7207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7208       };
7209     } catch (...) {
7210       {
7211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7212       };
7213     }
7214   }
7215   jresult = result;
7216   return jresult;
7217 }
7218
7219
7220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7221   unsigned int jresult ;
7222   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7223   Dali::Vector4 *arg2 = 0 ;
7224   bool result;
7225
7226   arg1 = (Dali::Vector4 *)jarg1;
7227   arg2 = (Dali::Vector4 *)jarg2;
7228   if (!arg2) {
7229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7230     return 0;
7231   }
7232   {
7233     try {
7234       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7235     } catch (std::out_of_range& e) {
7236       {
7237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7238       };
7239     } catch (std::exception& e) {
7240       {
7241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7242       };
7243     } catch (...) {
7244       {
7245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7246       };
7247     }
7248   }
7249   jresult = result;
7250   return jresult;
7251 }
7252
7253
7254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7255   float jresult ;
7256   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7257   unsigned int arg2 ;
7258   float *result = 0 ;
7259
7260   arg1 = (Dali::Vector4 *)jarg1;
7261   arg2 = (unsigned int)jarg2;
7262   {
7263     try {
7264       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7265     } catch (std::out_of_range& e) {
7266       {
7267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7268       };
7269     } catch (std::exception& e) {
7270       {
7271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7272       };
7273     } catch (...) {
7274       {
7275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7276       };
7277     }
7278   }
7279   jresult = *result;
7280   return jresult;
7281 }
7282
7283
7284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7285   float jresult ;
7286   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7287   Dali::Vector3 *arg2 = 0 ;
7288   float result;
7289
7290   arg1 = (Dali::Vector4 *)jarg1;
7291   arg2 = (Dali::Vector3 *)jarg2;
7292   if (!arg2) {
7293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7294     return 0;
7295   }
7296   {
7297     try {
7298       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7299     } catch (std::out_of_range& e) {
7300       {
7301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7302       };
7303     } catch (std::exception& e) {
7304       {
7305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7306       };
7307     } catch (...) {
7308       {
7309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7310       };
7311     }
7312   }
7313   jresult = result;
7314   return jresult;
7315 }
7316
7317
7318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7319   float jresult ;
7320   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7321   Dali::Vector4 *arg2 = 0 ;
7322   float result;
7323
7324   arg1 = (Dali::Vector4 *)jarg1;
7325   arg2 = (Dali::Vector4 *)jarg2;
7326   if (!arg2) {
7327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7328     return 0;
7329   }
7330   {
7331     try {
7332       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7333     } catch (std::out_of_range& e) {
7334       {
7335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7336       };
7337     } catch (std::exception& e) {
7338       {
7339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7340       };
7341     } catch (...) {
7342       {
7343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7344       };
7345     }
7346   }
7347   jresult = result;
7348   return jresult;
7349 }
7350
7351
7352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7353   float jresult ;
7354   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7355   Dali::Vector4 *arg2 = 0 ;
7356   float result;
7357
7358   arg1 = (Dali::Vector4 *)jarg1;
7359   arg2 = (Dali::Vector4 *)jarg2;
7360   if (!arg2) {
7361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7362     return 0;
7363   }
7364   {
7365     try {
7366       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7367     } catch (std::out_of_range& e) {
7368       {
7369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7370       };
7371     } catch (std::exception& e) {
7372       {
7373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7374       };
7375     } catch (...) {
7376       {
7377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7378       };
7379     }
7380   }
7381   jresult = result;
7382   return jresult;
7383 }
7384
7385
7386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7387   void * jresult ;
7388   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7389   Dali::Vector4 *arg2 = 0 ;
7390   Dali::Vector4 result;
7391
7392   arg1 = (Dali::Vector4 *)jarg1;
7393   arg2 = (Dali::Vector4 *)jarg2;
7394   if (!arg2) {
7395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7396     return 0;
7397   }
7398   {
7399     try {
7400       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7401     } catch (std::out_of_range& e) {
7402       {
7403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7404       };
7405     } catch (std::exception& e) {
7406       {
7407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7408       };
7409     } catch (...) {
7410       {
7411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7412       };
7413     }
7414   }
7415   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7416   return jresult;
7417 }
7418
7419
7420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7421   float jresult ;
7422   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7423   float result;
7424
7425   arg1 = (Dali::Vector4 *)jarg1;
7426   {
7427     try {
7428       result = (float)((Dali::Vector4 const *)arg1)->Length();
7429     } catch (std::out_of_range& e) {
7430       {
7431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7432       };
7433     } catch (std::exception& e) {
7434       {
7435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7436       };
7437     } catch (...) {
7438       {
7439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7440       };
7441     }
7442   }
7443   jresult = result;
7444   return jresult;
7445 }
7446
7447
7448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7449   float jresult ;
7450   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7451   float result;
7452
7453   arg1 = (Dali::Vector4 *)jarg1;
7454   {
7455     try {
7456       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7457     } catch (std::out_of_range& e) {
7458       {
7459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7460       };
7461     } catch (std::exception& e) {
7462       {
7463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7464       };
7465     } catch (...) {
7466       {
7467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7468       };
7469     }
7470   }
7471   jresult = result;
7472   return jresult;
7473 }
7474
7475
7476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7477   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7478
7479   arg1 = (Dali::Vector4 *)jarg1;
7480   {
7481     try {
7482       (arg1)->Normalize();
7483     } catch (std::out_of_range& e) {
7484       {
7485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7486       };
7487     } catch (std::exception& e) {
7488       {
7489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7490       };
7491     } catch (...) {
7492       {
7493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7494       };
7495     }
7496   }
7497 }
7498
7499
7500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7501   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7502   Dali::Vector4 *arg2 = 0 ;
7503   Dali::Vector4 *arg3 = 0 ;
7504
7505   arg1 = (Dali::Vector4 *)jarg1;
7506   arg2 = (Dali::Vector4 *)jarg2;
7507   if (!arg2) {
7508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7509     return ;
7510   }
7511   arg3 = (Dali::Vector4 *)jarg3;
7512   if (!arg3) {
7513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7514     return ;
7515   }
7516   {
7517     try {
7518       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7519     } catch (std::out_of_range& e) {
7520       {
7521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7522       };
7523     } catch (std::exception& e) {
7524       {
7525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7526       };
7527     } catch (...) {
7528       {
7529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7530       };
7531     }
7532   }
7533 }
7534
7535
7536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7537   void * jresult ;
7538   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7539   float *result = 0 ;
7540
7541   arg1 = (Dali::Vector4 *)jarg1;
7542   {
7543     try {
7544       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7545     } catch (std::out_of_range& e) {
7546       {
7547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7548       };
7549     } catch (std::exception& e) {
7550       {
7551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7552       };
7553     } catch (...) {
7554       {
7555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7556       };
7557     }
7558   }
7559   jresult = (void *)result;
7560   return jresult;
7561 }
7562
7563
7564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7566   float arg2 ;
7567
7568   arg1 = (Dali::Vector4 *)jarg1;
7569   arg2 = (float)jarg2;
7570   if (arg1) (arg1)->x = arg2;
7571 }
7572
7573
7574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7575   float jresult ;
7576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7577   float result;
7578
7579   arg1 = (Dali::Vector4 *)jarg1;
7580   result = (float) ((arg1)->x);
7581   jresult = result;
7582   return jresult;
7583 }
7584
7585
7586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7587   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7588   float arg2 ;
7589
7590   arg1 = (Dali::Vector4 *)jarg1;
7591   arg2 = (float)jarg2;
7592   if (arg1) (arg1)->r = arg2;
7593 }
7594
7595
7596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7597   float jresult ;
7598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7599   float result;
7600
7601   arg1 = (Dali::Vector4 *)jarg1;
7602   result = (float) ((arg1)->r);
7603   jresult = result;
7604   return jresult;
7605 }
7606
7607
7608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7610   float arg2 ;
7611
7612   arg1 = (Dali::Vector4 *)jarg1;
7613   arg2 = (float)jarg2;
7614   if (arg1) (arg1)->s = arg2;
7615 }
7616
7617
7618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7619   float jresult ;
7620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7621   float result;
7622
7623   arg1 = (Dali::Vector4 *)jarg1;
7624   result = (float) ((arg1)->s);
7625   jresult = result;
7626   return jresult;
7627 }
7628
7629
7630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7632   float arg2 ;
7633
7634   arg1 = (Dali::Vector4 *)jarg1;
7635   arg2 = (float)jarg2;
7636   if (arg1) (arg1)->y = arg2;
7637 }
7638
7639
7640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7641   float jresult ;
7642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7643   float result;
7644
7645   arg1 = (Dali::Vector4 *)jarg1;
7646   result = (float) ((arg1)->y);
7647   jresult = result;
7648   return jresult;
7649 }
7650
7651
7652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7654   float arg2 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   arg2 = (float)jarg2;
7658   if (arg1) (arg1)->g = arg2;
7659 }
7660
7661
7662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7663   float jresult ;
7664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7665   float result;
7666
7667   arg1 = (Dali::Vector4 *)jarg1;
7668   result = (float) ((arg1)->g);
7669   jresult = result;
7670   return jresult;
7671 }
7672
7673
7674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7676   float arg2 ;
7677
7678   arg1 = (Dali::Vector4 *)jarg1;
7679   arg2 = (float)jarg2;
7680   if (arg1) (arg1)->t = arg2;
7681 }
7682
7683
7684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7685   float jresult ;
7686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7687   float result;
7688
7689   arg1 = (Dali::Vector4 *)jarg1;
7690   result = (float) ((arg1)->t);
7691   jresult = result;
7692   return jresult;
7693 }
7694
7695
7696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7698   float arg2 ;
7699
7700   arg1 = (Dali::Vector4 *)jarg1;
7701   arg2 = (float)jarg2;
7702   if (arg1) (arg1)->z = arg2;
7703 }
7704
7705
7706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7707   float jresult ;
7708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7709   float result;
7710
7711   arg1 = (Dali::Vector4 *)jarg1;
7712   result = (float) ((arg1)->z);
7713   jresult = result;
7714   return jresult;
7715 }
7716
7717
7718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7720   float arg2 ;
7721
7722   arg1 = (Dali::Vector4 *)jarg1;
7723   arg2 = (float)jarg2;
7724   if (arg1) (arg1)->b = arg2;
7725 }
7726
7727
7728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7729   float jresult ;
7730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7731   float result;
7732
7733   arg1 = (Dali::Vector4 *)jarg1;
7734   result = (float) ((arg1)->b);
7735   jresult = result;
7736   return jresult;
7737 }
7738
7739
7740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7742   float arg2 ;
7743
7744   arg1 = (Dali::Vector4 *)jarg1;
7745   arg2 = (float)jarg2;
7746   if (arg1) (arg1)->p = arg2;
7747 }
7748
7749
7750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7751   float jresult ;
7752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7753   float result;
7754
7755   arg1 = (Dali::Vector4 *)jarg1;
7756   result = (float) ((arg1)->p);
7757   jresult = result;
7758   return jresult;
7759 }
7760
7761
7762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7764   float arg2 ;
7765
7766   arg1 = (Dali::Vector4 *)jarg1;
7767   arg2 = (float)jarg2;
7768   if (arg1) (arg1)->w = arg2;
7769 }
7770
7771
7772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7773   float jresult ;
7774   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7775   float result;
7776
7777   arg1 = (Dali::Vector4 *)jarg1;
7778   result = (float) ((arg1)->w);
7779   jresult = result;
7780   return jresult;
7781 }
7782
7783
7784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7785   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7786   float arg2 ;
7787
7788   arg1 = (Dali::Vector4 *)jarg1;
7789   arg2 = (float)jarg2;
7790   if (arg1) (arg1)->a = arg2;
7791 }
7792
7793
7794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7795   float jresult ;
7796   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7797   float result;
7798
7799   arg1 = (Dali::Vector4 *)jarg1;
7800   result = (float) ((arg1)->a);
7801   jresult = result;
7802   return jresult;
7803 }
7804
7805
7806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7808   float arg2 ;
7809
7810   arg1 = (Dali::Vector4 *)jarg1;
7811   arg2 = (float)jarg2;
7812   if (arg1) (arg1)->q = arg2;
7813 }
7814
7815
7816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7817   float jresult ;
7818   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7819   float result;
7820
7821   arg1 = (Dali::Vector4 *)jarg1;
7822   result = (float) ((arg1)->q);
7823   jresult = result;
7824   return jresult;
7825 }
7826
7827
7828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7830
7831   arg1 = (Dali::Vector4 *)jarg1;
7832   {
7833     try {
7834       delete arg1;
7835     } catch (std::out_of_range& e) {
7836       {
7837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7838       };
7839     } catch (std::exception& e) {
7840       {
7841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7842       };
7843     } catch (...) {
7844       {
7845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7846       };
7847     }
7848   }
7849 }
7850
7851
7852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7853   void * jresult ;
7854   Dali::Vector4 *arg1 = 0 ;
7855   Dali::Vector4 *arg2 = 0 ;
7856   Dali::Vector4 result;
7857
7858   arg1 = (Dali::Vector4 *)jarg1;
7859   if (!arg1) {
7860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7861     return 0;
7862   }
7863   arg2 = (Dali::Vector4 *)jarg2;
7864   if (!arg2) {
7865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7866     return 0;
7867   }
7868   {
7869     try {
7870       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7871     } catch (std::out_of_range& e) {
7872       {
7873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7874       };
7875     } catch (std::exception& e) {
7876       {
7877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7878       };
7879     } catch (...) {
7880       {
7881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7882       };
7883     }
7884   }
7885   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7886   return jresult;
7887 }
7888
7889
7890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7891   void * jresult ;
7892   Dali::Vector4 *arg1 = 0 ;
7893   Dali::Vector4 *arg2 = 0 ;
7894   Dali::Vector4 result;
7895
7896   arg1 = (Dali::Vector4 *)jarg1;
7897   if (!arg1) {
7898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7899     return 0;
7900   }
7901   arg2 = (Dali::Vector4 *)jarg2;
7902   if (!arg2) {
7903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7904     return 0;
7905   }
7906   {
7907     try {
7908       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7909     } catch (std::out_of_range& e) {
7910       {
7911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7912       };
7913     } catch (std::exception& e) {
7914       {
7915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7916       };
7917     } catch (...) {
7918       {
7919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7920       };
7921     }
7922   }
7923   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7924   return jresult;
7925 }
7926
7927
7928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7929   void * jresult ;
7930   Dali::Vector4 *arg1 = 0 ;
7931   float *arg2 = 0 ;
7932   float *arg3 = 0 ;
7933   float temp2 ;
7934   float temp3 ;
7935   Dali::Vector4 result;
7936
7937   arg1 = (Dali::Vector4 *)jarg1;
7938   if (!arg1) {
7939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7940     return 0;
7941   }
7942   temp2 = (float)jarg2;
7943   arg2 = &temp2;
7944   temp3 = (float)jarg3;
7945   arg3 = &temp3;
7946   {
7947     try {
7948       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7949     } catch (std::out_of_range& e) {
7950       {
7951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7952       };
7953     } catch (std::exception& e) {
7954       {
7955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7956       };
7957     } catch (...) {
7958       {
7959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7960       };
7961     }
7962   }
7963   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7964   return jresult;
7965 }
7966
7967
7968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
7969   void * jresult ;
7970   Dali::Uint16Pair *result = 0 ;
7971
7972   {
7973     try {
7974       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7975     } catch (std::out_of_range& e) {
7976       {
7977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7978       };
7979     } catch (std::exception& e) {
7980       {
7981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7982       };
7983     } catch (...) {
7984       {
7985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7986       };
7987     }
7988   }
7989   jresult = (void *)result;
7990   return jresult;
7991 }
7992
7993
7994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
7995   void * jresult ;
7996   uint32_t arg1 ;
7997   uint32_t arg2 ;
7998   Dali::Uint16Pair *result = 0 ;
7999
8000   arg1 = (uint32_t)jarg1;
8001   arg2 = (uint32_t)jarg2;
8002   {
8003     try {
8004       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8005     } catch (std::out_of_range& e) {
8006       {
8007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8008       };
8009     } catch (std::exception& e) {
8010       {
8011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8012       };
8013     } catch (...) {
8014       {
8015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8016       };
8017     }
8018   }
8019   jresult = (void *)result;
8020   return jresult;
8021 }
8022
8023
8024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8025   void * jresult ;
8026   Dali::Uint16Pair *arg1 = 0 ;
8027   Dali::Uint16Pair *result = 0 ;
8028
8029   arg1 = (Dali::Uint16Pair *)jarg1;
8030   if (!arg1) {
8031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8032     return 0;
8033   }
8034   {
8035     try {
8036       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8037     } catch (std::out_of_range& e) {
8038       {
8039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8040       };
8041     } catch (std::exception& e) {
8042       {
8043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (...) {
8046       {
8047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8048       };
8049     }
8050   }
8051   jresult = (void *)result;
8052   return jresult;
8053 }
8054
8055
8056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8057   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8058   uint16_t arg2 ;
8059
8060   arg1 = (Dali::Uint16Pair *)jarg1;
8061   arg2 = (uint16_t)jarg2;
8062   {
8063     try {
8064       (arg1)->SetWidth(arg2);
8065     } catch (std::out_of_range& e) {
8066       {
8067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8068       };
8069     } catch (std::exception& e) {
8070       {
8071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8072       };
8073     } catch (...) {
8074       {
8075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8076       };
8077     }
8078   }
8079 }
8080
8081
8082 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8083   unsigned short jresult ;
8084   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8085   uint16_t result;
8086
8087   arg1 = (Dali::Uint16Pair *)jarg1;
8088   {
8089     try {
8090       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8091     } catch (std::out_of_range& e) {
8092       {
8093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8094       };
8095     } catch (std::exception& e) {
8096       {
8097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8098       };
8099     } catch (...) {
8100       {
8101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8102       };
8103     }
8104   }
8105   jresult = result;
8106   return jresult;
8107 }
8108
8109
8110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8111   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8112   uint16_t arg2 ;
8113
8114   arg1 = (Dali::Uint16Pair *)jarg1;
8115   arg2 = (uint16_t)jarg2;
8116   {
8117     try {
8118       (arg1)->SetHeight(arg2);
8119     } catch (std::out_of_range& e) {
8120       {
8121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8122       };
8123     } catch (std::exception& e) {
8124       {
8125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8126       };
8127     } catch (...) {
8128       {
8129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8130       };
8131     }
8132   }
8133 }
8134
8135
8136 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8137   unsigned short jresult ;
8138   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8139   uint16_t result;
8140
8141   arg1 = (Dali::Uint16Pair *)jarg1;
8142   {
8143     try {
8144       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8145     } catch (std::out_of_range& e) {
8146       {
8147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8148       };
8149     } catch (std::exception& e) {
8150       {
8151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8152       };
8153     } catch (...) {
8154       {
8155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8156       };
8157     }
8158   }
8159   jresult = result;
8160   return jresult;
8161 }
8162
8163
8164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8165   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8166   uint16_t arg2 ;
8167
8168   arg1 = (Dali::Uint16Pair *)jarg1;
8169   arg2 = (uint16_t)jarg2;
8170   {
8171     try {
8172       (arg1)->SetX(arg2);
8173     } catch (std::out_of_range& e) {
8174       {
8175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8176       };
8177     } catch (std::exception& e) {
8178       {
8179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8180       };
8181     } catch (...) {
8182       {
8183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8184       };
8185     }
8186   }
8187 }
8188
8189
8190 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8191   unsigned short jresult ;
8192   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8193   uint16_t result;
8194
8195   arg1 = (Dali::Uint16Pair *)jarg1;
8196   {
8197     try {
8198       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8199     } catch (std::out_of_range& e) {
8200       {
8201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8202       };
8203     } catch (std::exception& e) {
8204       {
8205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8206       };
8207     } catch (...) {
8208       {
8209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8210       };
8211     }
8212   }
8213   jresult = result;
8214   return jresult;
8215 }
8216
8217
8218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8219   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8220   uint16_t arg2 ;
8221
8222   arg1 = (Dali::Uint16Pair *)jarg1;
8223   arg2 = (uint16_t)jarg2;
8224   {
8225     try {
8226       (arg1)->SetY(arg2);
8227     } catch (std::out_of_range& e) {
8228       {
8229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8230       };
8231     } catch (std::exception& e) {
8232       {
8233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8234       };
8235     } catch (...) {
8236       {
8237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8238       };
8239     }
8240   }
8241 }
8242
8243
8244 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8245   unsigned short jresult ;
8246   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8247   uint16_t result;
8248
8249   arg1 = (Dali::Uint16Pair *)jarg1;
8250   {
8251     try {
8252       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8253     } catch (std::out_of_range& e) {
8254       {
8255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8256       };
8257     } catch (std::exception& e) {
8258       {
8259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8260       };
8261     } catch (...) {
8262       {
8263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8264       };
8265     }
8266   }
8267   jresult = result;
8268   return jresult;
8269 }
8270
8271
8272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8273   void * jresult ;
8274   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8275   Dali::Uint16Pair *arg2 = 0 ;
8276   Dali::Uint16Pair *result = 0 ;
8277
8278   arg1 = (Dali::Uint16Pair *)jarg1;
8279   arg2 = (Dali::Uint16Pair *)jarg2;
8280   if (!arg2) {
8281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8282     return 0;
8283   }
8284   {
8285     try {
8286       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8287     } catch (std::out_of_range& e) {
8288       {
8289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8290       };
8291     } catch (std::exception& e) {
8292       {
8293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8294       };
8295     } catch (...) {
8296       {
8297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8298       };
8299     }
8300   }
8301   jresult = (void *)result;
8302   return jresult;
8303 }
8304
8305
8306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8307   unsigned int jresult ;
8308   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8309   Dali::Uint16Pair *arg2 = 0 ;
8310   bool result;
8311
8312   arg1 = (Dali::Uint16Pair *)jarg1;
8313   arg2 = (Dali::Uint16Pair *)jarg2;
8314   if (!arg2) {
8315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8316     return 0;
8317   }
8318   {
8319     try {
8320       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8321     } catch (std::out_of_range& e) {
8322       {
8323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8324       };
8325     } catch (std::exception& e) {
8326       {
8327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8328       };
8329     } catch (...) {
8330       {
8331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8332       };
8333     }
8334   }
8335   jresult = result;
8336   return jresult;
8337 }
8338
8339
8340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8341   unsigned int jresult ;
8342   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8343   Dali::Uint16Pair *arg2 = 0 ;
8344   bool result;
8345
8346   arg1 = (Dali::Uint16Pair *)jarg1;
8347   arg2 = (Dali::Uint16Pair *)jarg2;
8348   if (!arg2) {
8349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8350     return 0;
8351   }
8352   {
8353     try {
8354       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8355     } catch (std::out_of_range& e) {
8356       {
8357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8358       };
8359     } catch (std::exception& e) {
8360       {
8361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8362       };
8363     } catch (...) {
8364       {
8365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8366       };
8367     }
8368   }
8369   jresult = result;
8370   return jresult;
8371 }
8372
8373
8374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8375   unsigned int jresult ;
8376   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8377   Dali::Uint16Pair *arg2 = 0 ;
8378   bool result;
8379
8380   arg1 = (Dali::Uint16Pair *)jarg1;
8381   arg2 = (Dali::Uint16Pair *)jarg2;
8382   if (!arg2) {
8383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8384     return 0;
8385   }
8386   {
8387     try {
8388       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8389     } catch (std::out_of_range& e) {
8390       {
8391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8392       };
8393     } catch (std::exception& e) {
8394       {
8395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8396       };
8397     } catch (...) {
8398       {
8399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8400       };
8401     }
8402   }
8403   jresult = result;
8404   return jresult;
8405 }
8406
8407
8408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8409   unsigned int jresult ;
8410   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8411   Dali::Uint16Pair *arg2 = 0 ;
8412   bool result;
8413
8414   arg1 = (Dali::Uint16Pair *)jarg1;
8415   arg2 = (Dali::Uint16Pair *)jarg2;
8416   if (!arg2) {
8417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8418     return 0;
8419   }
8420   {
8421     try {
8422       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8423     } catch (std::out_of_range& e) {
8424       {
8425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8426       };
8427     } catch (std::exception& e) {
8428       {
8429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8430       };
8431     } catch (...) {
8432       {
8433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8434       };
8435     }
8436   }
8437   jresult = result;
8438   return jresult;
8439 }
8440
8441
8442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8443   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8444
8445   arg1 = (Dali::Uint16Pair *)jarg1;
8446   {
8447     try {
8448       delete arg1;
8449     } catch (std::out_of_range& e) {
8450       {
8451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8452       };
8453     } catch (std::exception& e) {
8454       {
8455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8456       };
8457     } catch (...) {
8458       {
8459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8460       };
8461     }
8462   }
8463 }
8464
8465
8466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8467   void * jresult ;
8468   Dali::Degree *result = 0 ;
8469
8470   {
8471     try {
8472       result = (Dali::Degree *)new Dali::Degree();
8473     } catch (std::out_of_range& e) {
8474       {
8475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8476       };
8477     } catch (std::exception& e) {
8478       {
8479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8480       };
8481     } catch (...) {
8482       {
8483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8484       };
8485     }
8486   }
8487   jresult = (void *)result;
8488   return jresult;
8489 }
8490
8491
8492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8493   void * jresult ;
8494   float arg1 ;
8495   Dali::Degree *result = 0 ;
8496
8497   arg1 = (float)jarg1;
8498   {
8499     try {
8500       result = (Dali::Degree *)new Dali::Degree(arg1);
8501     } catch (std::out_of_range& e) {
8502       {
8503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8504       };
8505     } catch (std::exception& e) {
8506       {
8507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8508       };
8509     } catch (...) {
8510       {
8511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8512       };
8513     }
8514   }
8515   jresult = (void *)result;
8516   return jresult;
8517 }
8518
8519
8520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8521   void * jresult ;
8522   Dali::Radian arg1 ;
8523   Dali::Radian *argp1 ;
8524   Dali::Degree *result = 0 ;
8525
8526   argp1 = (Dali::Radian *)jarg1;
8527   if (!argp1) {
8528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8529     return 0;
8530   }
8531   arg1 = *argp1;
8532   {
8533     try {
8534       result = (Dali::Degree *)new Dali::Degree(arg1);
8535     } catch (std::out_of_range& e) {
8536       {
8537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8538       };
8539     } catch (std::exception& e) {
8540       {
8541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8542       };
8543     } catch (...) {
8544       {
8545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8546       };
8547     }
8548   }
8549   jresult = (void *)result;
8550   return jresult;
8551 }
8552
8553
8554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8555   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8556   float arg2 ;
8557
8558   arg1 = (Dali::Degree *)jarg1;
8559   arg2 = (float)jarg2;
8560   if (arg1) (arg1)->degree = arg2;
8561 }
8562
8563
8564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8565   float jresult ;
8566   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8567   float result;
8568
8569   arg1 = (Dali::Degree *)jarg1;
8570   result = (float) ((arg1)->degree);
8571   jresult = result;
8572   return jresult;
8573 }
8574
8575
8576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8577   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8578
8579   arg1 = (Dali::Degree *)jarg1;
8580   {
8581     try {
8582       delete arg1;
8583     } catch (std::out_of_range& e) {
8584       {
8585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8586       };
8587     } catch (std::exception& e) {
8588       {
8589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8590       };
8591     } catch (...) {
8592       {
8593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8594       };
8595     }
8596   }
8597 }
8598
8599
8600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8601   void * jresult ;
8602   Dali::Radian *result = 0 ;
8603
8604   result = (Dali::Radian *)&Dali::ANGLE_360;
8605   jresult = (void *)result;
8606   return jresult;
8607 }
8608
8609
8610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8611   void * jresult ;
8612   Dali::Radian *result = 0 ;
8613
8614   result = (Dali::Radian *)&Dali::ANGLE_315;
8615   jresult = (void *)result;
8616   return jresult;
8617 }
8618
8619
8620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8621   void * jresult ;
8622   Dali::Radian *result = 0 ;
8623
8624   result = (Dali::Radian *)&Dali::ANGLE_270;
8625   jresult = (void *)result;
8626   return jresult;
8627 }
8628
8629
8630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8631   void * jresult ;
8632   Dali::Radian *result = 0 ;
8633
8634   result = (Dali::Radian *)&Dali::ANGLE_225;
8635   jresult = (void *)result;
8636   return jresult;
8637 }
8638
8639
8640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8641   void * jresult ;
8642   Dali::Radian *result = 0 ;
8643
8644   result = (Dali::Radian *)&Dali::ANGLE_180;
8645   jresult = (void *)result;
8646   return jresult;
8647 }
8648
8649
8650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8651   void * jresult ;
8652   Dali::Radian *result = 0 ;
8653
8654   result = (Dali::Radian *)&Dali::ANGLE_135;
8655   jresult = (void *)result;
8656   return jresult;
8657 }
8658
8659
8660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8661   void * jresult ;
8662   Dali::Radian *result = 0 ;
8663
8664   result = (Dali::Radian *)&Dali::ANGLE_120;
8665   jresult = (void *)result;
8666   return jresult;
8667 }
8668
8669
8670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8671   void * jresult ;
8672   Dali::Radian *result = 0 ;
8673
8674   result = (Dali::Radian *)&Dali::ANGLE_90;
8675   jresult = (void *)result;
8676   return jresult;
8677 }
8678
8679
8680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8681   void * jresult ;
8682   Dali::Radian *result = 0 ;
8683
8684   result = (Dali::Radian *)&Dali::ANGLE_60;
8685   jresult = (void *)result;
8686   return jresult;
8687 }
8688
8689
8690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8691   void * jresult ;
8692   Dali::Radian *result = 0 ;
8693
8694   result = (Dali::Radian *)&Dali::ANGLE_45;
8695   jresult = (void *)result;
8696   return jresult;
8697 }
8698
8699
8700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8701   void * jresult ;
8702   Dali::Radian *result = 0 ;
8703
8704   result = (Dali::Radian *)&Dali::ANGLE_30;
8705   jresult = (void *)result;
8706   return jresult;
8707 }
8708
8709
8710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8711   void * jresult ;
8712   Dali::Radian *result = 0 ;
8713
8714   result = (Dali::Radian *)&Dali::ANGLE_0;
8715   jresult = (void *)result;
8716   return jresult;
8717 }
8718
8719
8720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8721   unsigned int jresult ;
8722   Dali::Degree *arg1 = 0 ;
8723   Dali::Degree *arg2 = 0 ;
8724   bool result;
8725
8726   arg1 = (Dali::Degree *)jarg1;
8727   if (!arg1) {
8728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8729     return 0;
8730   }
8731   arg2 = (Dali::Degree *)jarg2;
8732   if (!arg2) {
8733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8734     return 0;
8735   }
8736   {
8737     try {
8738       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8739     } catch (std::out_of_range& e) {
8740       {
8741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8742       };
8743     } catch (std::exception& e) {
8744       {
8745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8746       };
8747     } catch (...) {
8748       {
8749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8750       };
8751     }
8752   }
8753   jresult = result;
8754   return jresult;
8755 }
8756
8757
8758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8759   unsigned int jresult ;
8760   Dali::Degree *arg1 = 0 ;
8761   Dali::Degree *arg2 = 0 ;
8762   bool result;
8763
8764   arg1 = (Dali::Degree *)jarg1;
8765   if (!arg1) {
8766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8767     return 0;
8768   }
8769   arg2 = (Dali::Degree *)jarg2;
8770   if (!arg2) {
8771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8772     return 0;
8773   }
8774   {
8775     try {
8776       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8777     } catch (std::out_of_range& e) {
8778       {
8779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8780       };
8781     } catch (std::exception& e) {
8782       {
8783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8784       };
8785     } catch (...) {
8786       {
8787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8788       };
8789     }
8790   }
8791   jresult = result;
8792   return jresult;
8793 }
8794
8795
8796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8797   void * jresult ;
8798   Dali::Degree arg1 ;
8799   float arg2 ;
8800   float arg3 ;
8801   Dali::Degree *argp1 ;
8802   Dali::Degree result;
8803
8804   argp1 = (Dali::Degree *)jarg1;
8805   if (!argp1) {
8806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8807     return 0;
8808   }
8809   arg1 = *argp1;
8810   arg2 = (float)jarg2;
8811   arg3 = (float)jarg3;
8812   {
8813     try {
8814       result = Dali::Clamp(arg1,arg2,arg3);
8815     } catch (std::out_of_range& e) {
8816       {
8817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8818       };
8819     } catch (std::exception& e) {
8820       {
8821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8822       };
8823     } catch (...) {
8824       {
8825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8826       };
8827     }
8828   }
8829   jresult = new Dali::Degree((const Dali::Degree &)result);
8830   return jresult;
8831 }
8832
8833
8834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8835   void * jresult ;
8836   Dali::Radian *result = 0 ;
8837
8838   {
8839     try {
8840       result = (Dali::Radian *)new Dali::Radian();
8841     } catch (std::out_of_range& e) {
8842       {
8843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8844       };
8845     } catch (std::exception& e) {
8846       {
8847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8848       };
8849     } catch (...) {
8850       {
8851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8852       };
8853     }
8854   }
8855   jresult = (void *)result;
8856   return jresult;
8857 }
8858
8859
8860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8861   void * jresult ;
8862   float arg1 ;
8863   Dali::Radian *result = 0 ;
8864
8865   arg1 = (float)jarg1;
8866   {
8867     try {
8868       result = (Dali::Radian *)new Dali::Radian(arg1);
8869     } catch (std::out_of_range& e) {
8870       {
8871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8872       };
8873     } catch (std::exception& e) {
8874       {
8875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8876       };
8877     } catch (...) {
8878       {
8879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8880       };
8881     }
8882   }
8883   jresult = (void *)result;
8884   return jresult;
8885 }
8886
8887
8888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8889   void * jresult ;
8890   Dali::Degree arg1 ;
8891   Dali::Degree *argp1 ;
8892   Dali::Radian *result = 0 ;
8893
8894   argp1 = (Dali::Degree *)jarg1;
8895   if (!argp1) {
8896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8897     return 0;
8898   }
8899   arg1 = *argp1;
8900   {
8901     try {
8902       result = (Dali::Radian *)new Dali::Radian(arg1);
8903     } catch (std::out_of_range& e) {
8904       {
8905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8906       };
8907     } catch (std::exception& e) {
8908       {
8909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8910       };
8911     } catch (...) {
8912       {
8913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8914       };
8915     }
8916   }
8917   jresult = (void *)result;
8918   return jresult;
8919 }
8920
8921
8922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8923   void * jresult ;
8924   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8925   float arg2 ;
8926   Dali::Radian *result = 0 ;
8927
8928   arg1 = (Dali::Radian *)jarg1;
8929   arg2 = (float)jarg2;
8930   {
8931     try {
8932       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8933     } catch (std::out_of_range& e) {
8934       {
8935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8936       };
8937     } catch (std::exception& e) {
8938       {
8939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8940       };
8941     } catch (...) {
8942       {
8943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8944       };
8945     }
8946   }
8947   jresult = (void *)result;
8948   return jresult;
8949 }
8950
8951
8952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8953   void * jresult ;
8954   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8955   Dali::Degree arg2 ;
8956   Dali::Degree *argp2 ;
8957   Dali::Radian *result = 0 ;
8958
8959   arg1 = (Dali::Radian *)jarg1;
8960   argp2 = (Dali::Degree *)jarg2;
8961   if (!argp2) {
8962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8963     return 0;
8964   }
8965   arg2 = *argp2;
8966   {
8967     try {
8968       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8969     } catch (std::out_of_range& e) {
8970       {
8971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (std::exception& e) {
8974       {
8975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8976       };
8977     } catch (...) {
8978       {
8979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8980       };
8981     }
8982   }
8983   jresult = (void *)result;
8984   return jresult;
8985 }
8986
8987
8988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
8989   float jresult ;
8990   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8991   float result;
8992
8993   arg1 = (Dali::Radian *)jarg1;
8994   {
8995     try {
8996       result = (float)((Dali::Radian const *)arg1)->operator float();
8997     } catch (std::out_of_range& e) {
8998       {
8999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9000       };
9001     } catch (std::exception& e) {
9002       {
9003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9004       };
9005     } catch (...) {
9006       {
9007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9008       };
9009     }
9010   }
9011   jresult = result;
9012   return jresult;
9013 }
9014
9015
9016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9017   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9018   float arg2 ;
9019
9020   arg1 = (Dali::Radian *)jarg1;
9021   arg2 = (float)jarg2;
9022   if (arg1) (arg1)->radian = arg2;
9023 }
9024
9025
9026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9027   float jresult ;
9028   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9029   float result;
9030
9031   arg1 = (Dali::Radian *)jarg1;
9032   result = (float) ((arg1)->radian);
9033   jresult = result;
9034   return jresult;
9035 }
9036
9037
9038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9039   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9040
9041   arg1 = (Dali::Radian *)jarg1;
9042   {
9043     try {
9044       delete arg1;
9045     } catch (std::out_of_range& e) {
9046       {
9047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9048       };
9049     } catch (std::exception& e) {
9050       {
9051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9052       };
9053     } catch (...) {
9054       {
9055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9056       };
9057     }
9058   }
9059 }
9060
9061
9062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9063   unsigned int jresult ;
9064   Dali::Radian arg1 ;
9065   Dali::Radian arg2 ;
9066   Dali::Radian *argp1 ;
9067   Dali::Radian *argp2 ;
9068   bool result;
9069
9070   argp1 = (Dali::Radian *)jarg1;
9071   if (!argp1) {
9072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9073     return 0;
9074   }
9075   arg1 = *argp1;
9076   argp2 = (Dali::Radian *)jarg2;
9077   if (!argp2) {
9078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9079     return 0;
9080   }
9081   arg2 = *argp2;
9082   {
9083     try {
9084       result = (bool)Dali::operator ==(arg1,arg2);
9085     } catch (std::out_of_range& e) {
9086       {
9087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9088       };
9089     } catch (std::exception& e) {
9090       {
9091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9092       };
9093     } catch (...) {
9094       {
9095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9096       };
9097     }
9098   }
9099   jresult = result;
9100   return jresult;
9101 }
9102
9103
9104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9105   unsigned int jresult ;
9106   Dali::Radian arg1 ;
9107   Dali::Radian arg2 ;
9108   Dali::Radian *argp1 ;
9109   Dali::Radian *argp2 ;
9110   bool result;
9111
9112   argp1 = (Dali::Radian *)jarg1;
9113   if (!argp1) {
9114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9115     return 0;
9116   }
9117   arg1 = *argp1;
9118   argp2 = (Dali::Radian *)jarg2;
9119   if (!argp2) {
9120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9121     return 0;
9122   }
9123   arg2 = *argp2;
9124   {
9125     try {
9126       result = (bool)Dali::operator !=(arg1,arg2);
9127     } catch (std::out_of_range& e) {
9128       {
9129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9130       };
9131     } catch (std::exception& e) {
9132       {
9133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9134       };
9135     } catch (...) {
9136       {
9137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9138       };
9139     }
9140   }
9141   jresult = result;
9142   return jresult;
9143 }
9144
9145
9146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9147   unsigned int jresult ;
9148   Dali::Radian arg1 ;
9149   Dali::Degree arg2 ;
9150   Dali::Radian *argp1 ;
9151   Dali::Degree *argp2 ;
9152   bool result;
9153
9154   argp1 = (Dali::Radian *)jarg1;
9155   if (!argp1) {
9156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9157     return 0;
9158   }
9159   arg1 = *argp1;
9160   argp2 = (Dali::Degree *)jarg2;
9161   if (!argp2) {
9162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9163     return 0;
9164   }
9165   arg2 = *argp2;
9166   {
9167     try {
9168       result = (bool)Dali::operator ==(arg1,arg2);
9169     } catch (std::out_of_range& e) {
9170       {
9171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9172       };
9173     } catch (std::exception& e) {
9174       {
9175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9176       };
9177     } catch (...) {
9178       {
9179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9180       };
9181     }
9182   }
9183   jresult = result;
9184   return jresult;
9185 }
9186
9187
9188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9189   unsigned int jresult ;
9190   Dali::Radian arg1 ;
9191   Dali::Degree arg2 ;
9192   Dali::Radian *argp1 ;
9193   Dali::Degree *argp2 ;
9194   bool result;
9195
9196   argp1 = (Dali::Radian *)jarg1;
9197   if (!argp1) {
9198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9199     return 0;
9200   }
9201   arg1 = *argp1;
9202   argp2 = (Dali::Degree *)jarg2;
9203   if (!argp2) {
9204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9205     return 0;
9206   }
9207   arg2 = *argp2;
9208   {
9209     try {
9210       result = (bool)Dali::operator !=(arg1,arg2);
9211     } catch (std::out_of_range& e) {
9212       {
9213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9214       };
9215     } catch (std::exception& e) {
9216       {
9217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9218       };
9219     } catch (...) {
9220       {
9221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9222       };
9223     }
9224   }
9225   jresult = result;
9226   return jresult;
9227 }
9228
9229
9230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9231   unsigned int jresult ;
9232   Dali::Degree arg1 ;
9233   Dali::Radian arg2 ;
9234   Dali::Degree *argp1 ;
9235   Dali::Radian *argp2 ;
9236   bool result;
9237
9238   argp1 = (Dali::Degree *)jarg1;
9239   if (!argp1) {
9240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9241     return 0;
9242   }
9243   arg1 = *argp1;
9244   argp2 = (Dali::Radian *)jarg2;
9245   if (!argp2) {
9246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9247     return 0;
9248   }
9249   arg2 = *argp2;
9250   {
9251     try {
9252       result = (bool)Dali::operator ==(arg1,arg2);
9253     } catch (std::out_of_range& e) {
9254       {
9255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9256       };
9257     } catch (std::exception& e) {
9258       {
9259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9260       };
9261     } catch (...) {
9262       {
9263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9264       };
9265     }
9266   }
9267   jresult = result;
9268   return jresult;
9269 }
9270
9271
9272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9273   unsigned int jresult ;
9274   Dali::Degree arg1 ;
9275   Dali::Radian arg2 ;
9276   Dali::Degree *argp1 ;
9277   Dali::Radian *argp2 ;
9278   bool result;
9279
9280   argp1 = (Dali::Degree *)jarg1;
9281   if (!argp1) {
9282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9283     return 0;
9284   }
9285   arg1 = *argp1;
9286   argp2 = (Dali::Radian *)jarg2;
9287   if (!argp2) {
9288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9289     return 0;
9290   }
9291   arg2 = *argp2;
9292   {
9293     try {
9294       result = (bool)Dali::operator !=(arg1,arg2);
9295     } catch (std::out_of_range& e) {
9296       {
9297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9298       };
9299     } catch (std::exception& e) {
9300       {
9301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9302       };
9303     } catch (...) {
9304       {
9305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9306       };
9307     }
9308   }
9309   jresult = result;
9310   return jresult;
9311 }
9312
9313
9314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9315   unsigned int jresult ;
9316   Dali::Radian arg1 ;
9317   Dali::Radian arg2 ;
9318   Dali::Radian *argp1 ;
9319   Dali::Radian *argp2 ;
9320   bool result;
9321
9322   argp1 = (Dali::Radian *)jarg1;
9323   if (!argp1) {
9324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9325     return 0;
9326   }
9327   arg1 = *argp1;
9328   argp2 = (Dali::Radian *)jarg2;
9329   if (!argp2) {
9330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9331     return 0;
9332   }
9333   arg2 = *argp2;
9334   {
9335     try {
9336       result = (bool)Dali::operator >(arg1,arg2);
9337     } catch (std::out_of_range& e) {
9338       {
9339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9340       };
9341     } catch (std::exception& e) {
9342       {
9343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9344       };
9345     } catch (...) {
9346       {
9347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9348       };
9349     }
9350   }
9351   jresult = result;
9352   return jresult;
9353 }
9354
9355
9356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9357   unsigned int jresult ;
9358   Dali::Radian arg1 ;
9359   Dali::Degree arg2 ;
9360   Dali::Radian *argp1 ;
9361   Dali::Degree *argp2 ;
9362   bool result;
9363
9364   argp1 = (Dali::Radian *)jarg1;
9365   if (!argp1) {
9366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9367     return 0;
9368   }
9369   arg1 = *argp1;
9370   argp2 = (Dali::Degree *)jarg2;
9371   if (!argp2) {
9372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9373     return 0;
9374   }
9375   arg2 = *argp2;
9376   {
9377     try {
9378       result = (bool)Dali::operator >(arg1,arg2);
9379     } catch (std::out_of_range& e) {
9380       {
9381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9382       };
9383     } catch (std::exception& e) {
9384       {
9385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9386       };
9387     } catch (...) {
9388       {
9389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9390       };
9391     }
9392   }
9393   jresult = result;
9394   return jresult;
9395 }
9396
9397
9398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9399   unsigned int jresult ;
9400   Dali::Degree arg1 ;
9401   Dali::Radian arg2 ;
9402   Dali::Degree *argp1 ;
9403   Dali::Radian *argp2 ;
9404   bool result;
9405
9406   argp1 = (Dali::Degree *)jarg1;
9407   if (!argp1) {
9408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9409     return 0;
9410   }
9411   arg1 = *argp1;
9412   argp2 = (Dali::Radian *)jarg2;
9413   if (!argp2) {
9414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9415     return 0;
9416   }
9417   arg2 = *argp2;
9418   {
9419     try {
9420       result = (bool)Dali::operator >(arg1,arg2);
9421     } catch (std::out_of_range& e) {
9422       {
9423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9424       };
9425     } catch (std::exception& e) {
9426       {
9427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9428       };
9429     } catch (...) {
9430       {
9431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9432       };
9433     }
9434   }
9435   jresult = result;
9436   return jresult;
9437 }
9438
9439
9440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9441   unsigned int jresult ;
9442   Dali::Radian arg1 ;
9443   Dali::Radian arg2 ;
9444   Dali::Radian *argp1 ;
9445   Dali::Radian *argp2 ;
9446   bool result;
9447
9448   argp1 = (Dali::Radian *)jarg1;
9449   if (!argp1) {
9450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9451     return 0;
9452   }
9453   arg1 = *argp1;
9454   argp2 = (Dali::Radian *)jarg2;
9455   if (!argp2) {
9456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9457     return 0;
9458   }
9459   arg2 = *argp2;
9460   {
9461     try {
9462       result = (bool)Dali::operator <(arg1,arg2);
9463     } catch (std::out_of_range& e) {
9464       {
9465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9466       };
9467     } catch (std::exception& e) {
9468       {
9469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9470       };
9471     } catch (...) {
9472       {
9473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9474       };
9475     }
9476   }
9477   jresult = result;
9478   return jresult;
9479 }
9480
9481
9482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9483   unsigned int jresult ;
9484   Dali::Radian arg1 ;
9485   Dali::Degree arg2 ;
9486   Dali::Radian *argp1 ;
9487   Dali::Degree *argp2 ;
9488   bool result;
9489
9490   argp1 = (Dali::Radian *)jarg1;
9491   if (!argp1) {
9492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9493     return 0;
9494   }
9495   arg1 = *argp1;
9496   argp2 = (Dali::Degree *)jarg2;
9497   if (!argp2) {
9498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9499     return 0;
9500   }
9501   arg2 = *argp2;
9502   {
9503     try {
9504       result = (bool)Dali::operator <(arg1,arg2);
9505     } catch (std::out_of_range& e) {
9506       {
9507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9508       };
9509     } catch (std::exception& e) {
9510       {
9511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9512       };
9513     } catch (...) {
9514       {
9515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9516       };
9517     }
9518   }
9519   jresult = result;
9520   return jresult;
9521 }
9522
9523
9524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9525   unsigned int jresult ;
9526   Dali::Degree arg1 ;
9527   Dali::Radian arg2 ;
9528   Dali::Degree *argp1 ;
9529   Dali::Radian *argp2 ;
9530   bool result;
9531
9532   argp1 = (Dali::Degree *)jarg1;
9533   if (!argp1) {
9534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9535     return 0;
9536   }
9537   arg1 = *argp1;
9538   argp2 = (Dali::Radian *)jarg2;
9539   if (!argp2) {
9540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9541     return 0;
9542   }
9543   arg2 = *argp2;
9544   {
9545     try {
9546       result = (bool)Dali::operator <(arg1,arg2);
9547     } catch (std::out_of_range& e) {
9548       {
9549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9550       };
9551     } catch (std::exception& e) {
9552       {
9553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9554       };
9555     } catch (...) {
9556       {
9557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9558       };
9559     }
9560   }
9561   jresult = result;
9562   return jresult;
9563 }
9564
9565
9566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9567   void * jresult ;
9568   Dali::Radian arg1 ;
9569   float arg2 ;
9570   Dali::Radian *argp1 ;
9571   Dali::Radian result;
9572
9573   argp1 = (Dali::Radian *)jarg1;
9574   if (!argp1) {
9575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9576     return 0;
9577   }
9578   arg1 = *argp1;
9579   arg2 = (float)jarg2;
9580   {
9581     try {
9582       result = Dali::operator *(arg1,arg2);
9583     } catch (std::out_of_range& e) {
9584       {
9585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (std::exception& e) {
9588       {
9589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9590       };
9591     } catch (...) {
9592       {
9593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9594       };
9595     }
9596   }
9597   jresult = new Dali::Radian((const Dali::Radian &)result);
9598   return jresult;
9599 }
9600
9601
9602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9603   void * jresult ;
9604   Dali::Radian arg1 ;
9605   Dali::Radian *argp1 ;
9606   Dali::Radian result;
9607
9608   argp1 = (Dali::Radian *)jarg1;
9609   if (!argp1) {
9610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9611     return 0;
9612   }
9613   arg1 = *argp1;
9614   {
9615     try {
9616       result = Dali::operator -(arg1);
9617     } catch (std::out_of_range& e) {
9618       {
9619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9620       };
9621     } catch (std::exception& e) {
9622       {
9623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9624       };
9625     } catch (...) {
9626       {
9627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9628       };
9629     }
9630   }
9631   jresult = new Dali::Radian((const Dali::Radian &)result);
9632   return jresult;
9633 }
9634
9635
9636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9637   void * jresult ;
9638   Dali::Radian arg1 ;
9639   float arg2 ;
9640   float arg3 ;
9641   Dali::Radian *argp1 ;
9642   Dali::Radian result;
9643
9644   argp1 = (Dali::Radian *)jarg1;
9645   if (!argp1) {
9646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9647     return 0;
9648   }
9649   arg1 = *argp1;
9650   arg2 = (float)jarg2;
9651   arg3 = (float)jarg3;
9652   {
9653     try {
9654       result = Dali::Clamp(arg1,arg2,arg3);
9655     } catch (std::out_of_range& e) {
9656       {
9657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9658       };
9659     } catch (std::exception& e) {
9660       {
9661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9662       };
9663     } catch (...) {
9664       {
9665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9666       };
9667     }
9668   }
9669   jresult = new Dali::Radian((const Dali::Radian &)result);
9670   return jresult;
9671 }
9672
9673
9674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9675   void * jresult ;
9676   Dali::Quaternion *result = 0 ;
9677
9678   {
9679     try {
9680       result = (Dali::Quaternion *)new Dali::Quaternion();
9681     } catch (std::out_of_range& e) {
9682       {
9683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9684       };
9685     } catch (std::exception& e) {
9686       {
9687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9688       };
9689     } catch (...) {
9690       {
9691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9692       };
9693     }
9694   }
9695   jresult = (void *)result;
9696   return jresult;
9697 }
9698
9699
9700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9701   void * jresult ;
9702   Dali::Radian arg1 ;
9703   Dali::Vector3 *arg2 = 0 ;
9704   Dali::Radian *argp1 ;
9705   Dali::Quaternion *result = 0 ;
9706
9707   argp1 = (Dali::Radian *)jarg1;
9708   if (!argp1) {
9709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9710     return 0;
9711   }
9712   arg1 = *argp1;
9713   arg2 = (Dali::Vector3 *)jarg2;
9714   if (!arg2) {
9715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9716     return 0;
9717   }
9718   {
9719     try {
9720       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9721     } catch (std::out_of_range& e) {
9722       {
9723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9724       };
9725     } catch (std::exception& e) {
9726       {
9727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9728       };
9729     } catch (...) {
9730       {
9731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9732       };
9733     }
9734   }
9735   jresult = (void *)result;
9736   return jresult;
9737 }
9738
9739
9740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9741   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9742
9743   arg1 = (Dali::Quaternion *)jarg1;
9744   {
9745     try {
9746       delete arg1;
9747     } catch (std::out_of_range& e) {
9748       {
9749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9750       };
9751     } catch (std::exception& e) {
9752       {
9753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9754       };
9755     } catch (...) {
9756       {
9757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9758       };
9759     }
9760   }
9761 }
9762
9763
9764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9765   void * jresult ;
9766   Dali::Quaternion *result = 0 ;
9767
9768   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9775   unsigned int jresult ;
9776   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9777   bool result;
9778
9779   arg1 = (Dali::Quaternion *)jarg1;
9780   {
9781     try {
9782       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9783     } catch (std::out_of_range& e) {
9784       {
9785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9786       };
9787     } catch (std::exception& e) {
9788       {
9789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9790       };
9791     } catch (...) {
9792       {
9793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9794       };
9795     }
9796   }
9797   jresult = result;
9798   return jresult;
9799 }
9800
9801
9802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9803   unsigned int jresult ;
9804   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9805   Dali::Vector3 *arg2 = 0 ;
9806   Dali::Radian *arg3 = 0 ;
9807   bool result;
9808
9809   arg1 = (Dali::Quaternion *)jarg1;
9810   arg2 = (Dali::Vector3 *)jarg2;
9811   if (!arg2) {
9812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9813     return 0;
9814   }
9815   arg3 = (Dali::Radian *)jarg3;
9816   if (!arg3) {
9817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9818     return 0;
9819   }
9820   {
9821     try {
9822       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9823     } catch (std::out_of_range& e) {
9824       {
9825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9826       };
9827     } catch (std::exception& e) {
9828       {
9829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9830       };
9831     } catch (...) {
9832       {
9833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9834       };
9835     }
9836   }
9837   jresult = result;
9838   return jresult;
9839 }
9840
9841
9842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9843   void * jresult ;
9844   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9845   Dali::Quaternion *arg2 = 0 ;
9846   Dali::Quaternion result;
9847
9848   arg1 = (Dali::Quaternion *)jarg1;
9849   arg2 = (Dali::Quaternion *)jarg2;
9850   if (!arg2) {
9851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9852     return 0;
9853   }
9854   {
9855     try {
9856       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9857     } catch (std::out_of_range& e) {
9858       {
9859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9860       };
9861     } catch (std::exception& e) {
9862       {
9863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9864       };
9865     } catch (...) {
9866       {
9867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9868       };
9869     }
9870   }
9871   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9872   return jresult;
9873 }
9874
9875
9876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9877   void * jresult ;
9878   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9879   Dali::Quaternion *arg2 = 0 ;
9880   Dali::Quaternion result;
9881
9882   arg1 = (Dali::Quaternion *)jarg1;
9883   arg2 = (Dali::Quaternion *)jarg2;
9884   if (!arg2) {
9885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9886     return 0;
9887   }
9888   {
9889     try {
9890       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9891     } catch (std::out_of_range& e) {
9892       {
9893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9894       };
9895     } catch (std::exception& e) {
9896       {
9897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9898       };
9899     } catch (...) {
9900       {
9901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9902       };
9903     }
9904   }
9905   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9906   return jresult;
9907 }
9908
9909
9910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9911   void * jresult ;
9912   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9913   Dali::Quaternion *arg2 = 0 ;
9914   Dali::Quaternion result;
9915
9916   arg1 = (Dali::Quaternion *)jarg1;
9917   arg2 = (Dali::Quaternion *)jarg2;
9918   if (!arg2) {
9919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9920     return 0;
9921   }
9922   {
9923     try {
9924       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9925     } catch (std::out_of_range& e) {
9926       {
9927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9928       };
9929     } catch (std::exception& e) {
9930       {
9931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9932       };
9933     } catch (...) {
9934       {
9935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9936       };
9937     }
9938   }
9939   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9940   return jresult;
9941 }
9942
9943
9944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9945   void * jresult ;
9946   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9947   Dali::Vector3 *arg2 = 0 ;
9948   Dali::Vector3 result;
9949
9950   arg1 = (Dali::Quaternion *)jarg1;
9951   arg2 = (Dali::Vector3 *)jarg2;
9952   if (!arg2) {
9953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9954     return 0;
9955   }
9956   {
9957     try {
9958       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9959     } catch (std::out_of_range& e) {
9960       {
9961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9962       };
9963     } catch (std::exception& e) {
9964       {
9965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9966       };
9967     } catch (...) {
9968       {
9969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9970       };
9971     }
9972   }
9973   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
9974   return jresult;
9975 }
9976
9977
9978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
9979   void * jresult ;
9980   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9981   Dali::Quaternion *arg2 = 0 ;
9982   Dali::Quaternion result;
9983
9984   arg1 = (Dali::Quaternion *)jarg1;
9985   arg2 = (Dali::Quaternion *)jarg2;
9986   if (!arg2) {
9987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9988     return 0;
9989   }
9990   {
9991     try {
9992       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
9993     } catch (std::out_of_range& e) {
9994       {
9995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9996       };
9997     } catch (std::exception& e) {
9998       {
9999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10000       };
10001     } catch (...) {
10002       {
10003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10004       };
10005     }
10006   }
10007   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10008   return jresult;
10009 }
10010
10011
10012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10013   void * jresult ;
10014   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10015   float arg2 ;
10016   Dali::Quaternion result;
10017
10018   arg1 = (Dali::Quaternion *)jarg1;
10019   arg2 = (float)jarg2;
10020   {
10021     try {
10022       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10023     } catch (std::out_of_range& e) {
10024       {
10025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10026       };
10027     } catch (std::exception& e) {
10028       {
10029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10030       };
10031     } catch (...) {
10032       {
10033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10034       };
10035     }
10036   }
10037   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10038   return jresult;
10039 }
10040
10041
10042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10043   void * jresult ;
10044   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10045   float arg2 ;
10046   Dali::Quaternion result;
10047
10048   arg1 = (Dali::Quaternion *)jarg1;
10049   arg2 = (float)jarg2;
10050   {
10051     try {
10052       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10053     } catch (std::out_of_range& e) {
10054       {
10055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10056       };
10057     } catch (std::exception& e) {
10058       {
10059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10060       };
10061     } catch (...) {
10062       {
10063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10064       };
10065     }
10066   }
10067   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10068   return jresult;
10069 }
10070
10071
10072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10073   void * jresult ;
10074   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10075   Dali::Quaternion result;
10076
10077   arg1 = (Dali::Quaternion *)jarg1;
10078   {
10079     try {
10080       result = ((Dali::Quaternion const *)arg1)->operator -();
10081     } catch (std::out_of_range& e) {
10082       {
10083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10084       };
10085     } catch (std::exception& e) {
10086       {
10087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10088       };
10089     } catch (...) {
10090       {
10091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10092       };
10093     }
10094   }
10095   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10096   return jresult;
10097 }
10098
10099
10100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10101   void * jresult ;
10102   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10103   Dali::Quaternion *arg2 = 0 ;
10104   Dali::Quaternion *result = 0 ;
10105
10106   arg1 = (Dali::Quaternion *)jarg1;
10107   arg2 = (Dali::Quaternion *)jarg2;
10108   if (!arg2) {
10109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10110     return 0;
10111   }
10112   {
10113     try {
10114       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10115     } catch (std::out_of_range& e) {
10116       {
10117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10118       };
10119     } catch (std::exception& e) {
10120       {
10121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10122       };
10123     } catch (...) {
10124       {
10125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10126       };
10127     }
10128   }
10129   jresult = (void *)result;
10130   return jresult;
10131 }
10132
10133
10134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10135   void * jresult ;
10136   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10137   Dali::Quaternion *arg2 = 0 ;
10138   Dali::Quaternion *result = 0 ;
10139
10140   arg1 = (Dali::Quaternion *)jarg1;
10141   arg2 = (Dali::Quaternion *)jarg2;
10142   if (!arg2) {
10143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10144     return 0;
10145   }
10146   {
10147     try {
10148       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10149     } catch (std::out_of_range& e) {
10150       {
10151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10152       };
10153     } catch (std::exception& e) {
10154       {
10155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10156       };
10157     } catch (...) {
10158       {
10159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10160       };
10161     }
10162   }
10163   jresult = (void *)result;
10164   return jresult;
10165 }
10166
10167
10168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10169   void * jresult ;
10170   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10171   Dali::Quaternion *arg2 = 0 ;
10172   Dali::Quaternion *result = 0 ;
10173
10174   arg1 = (Dali::Quaternion *)jarg1;
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   {
10181     try {
10182       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10183     } catch (std::out_of_range& e) {
10184       {
10185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10186       };
10187     } catch (std::exception& e) {
10188       {
10189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10190       };
10191     } catch (...) {
10192       {
10193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10194       };
10195     }
10196   }
10197   jresult = (void *)result;
10198   return jresult;
10199 }
10200
10201
10202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10203   void * jresult ;
10204   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10205   float arg2 ;
10206   Dali::Quaternion *result = 0 ;
10207
10208   arg1 = (Dali::Quaternion *)jarg1;
10209   arg2 = (float)jarg2;
10210   {
10211     try {
10212       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10213     } catch (std::out_of_range& e) {
10214       {
10215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10216       };
10217     } catch (std::exception& e) {
10218       {
10219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10220       };
10221     } catch (...) {
10222       {
10223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10224       };
10225     }
10226   }
10227   jresult = (void *)result;
10228   return jresult;
10229 }
10230
10231
10232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10233   void * jresult ;
10234   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10235   float arg2 ;
10236   Dali::Quaternion *result = 0 ;
10237
10238   arg1 = (Dali::Quaternion *)jarg1;
10239   arg2 = (float)jarg2;
10240   {
10241     try {
10242       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10243     } catch (std::out_of_range& e) {
10244       {
10245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10246       };
10247     } catch (std::exception& e) {
10248       {
10249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10250       };
10251     } catch (...) {
10252       {
10253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10254       };
10255     }
10256   }
10257   jresult = (void *)result;
10258   return jresult;
10259 }
10260
10261
10262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10263   unsigned int jresult ;
10264   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10265   Dali::Quaternion *arg2 = 0 ;
10266   bool result;
10267
10268   arg1 = (Dali::Quaternion *)jarg1;
10269   arg2 = (Dali::Quaternion *)jarg2;
10270   if (!arg2) {
10271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10272     return 0;
10273   }
10274   {
10275     try {
10276       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10277     } catch (std::out_of_range& e) {
10278       {
10279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (std::exception& e) {
10282       {
10283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10284       };
10285     } catch (...) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10288       };
10289     }
10290   }
10291   jresult = result;
10292   return jresult;
10293 }
10294
10295
10296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10297   unsigned int jresult ;
10298   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10299   Dali::Quaternion *arg2 = 0 ;
10300   bool result;
10301
10302   arg1 = (Dali::Quaternion *)jarg1;
10303   arg2 = (Dali::Quaternion *)jarg2;
10304   if (!arg2) {
10305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10306     return 0;
10307   }
10308   {
10309     try {
10310       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10311     } catch (std::out_of_range& e) {
10312       {
10313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10314       };
10315     } catch (std::exception& e) {
10316       {
10317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10318       };
10319     } catch (...) {
10320       {
10321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10322       };
10323     }
10324   }
10325   jresult = result;
10326   return jresult;
10327 }
10328
10329
10330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10331   float jresult ;
10332   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10333   float result;
10334
10335   arg1 = (Dali::Quaternion *)jarg1;
10336   {
10337     try {
10338       result = (float)((Dali::Quaternion const *)arg1)->Length();
10339     } catch (std::out_of_range& e) {
10340       {
10341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10342       };
10343     } catch (std::exception& e) {
10344       {
10345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10346       };
10347     } catch (...) {
10348       {
10349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10350       };
10351     }
10352   }
10353   jresult = result;
10354   return jresult;
10355 }
10356
10357
10358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10359   float jresult ;
10360   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10361   float result;
10362
10363   arg1 = (Dali::Quaternion *)jarg1;
10364   {
10365     try {
10366       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10367     } catch (std::out_of_range& e) {
10368       {
10369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10370       };
10371     } catch (std::exception& e) {
10372       {
10373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (...) {
10376       {
10377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10378       };
10379     }
10380   }
10381   jresult = result;
10382   return jresult;
10383 }
10384
10385
10386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10387   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10388
10389   arg1 = (Dali::Quaternion *)jarg1;
10390   {
10391     try {
10392       (arg1)->Normalize();
10393     } catch (std::out_of_range& e) {
10394       {
10395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10396       };
10397     } catch (std::exception& e) {
10398       {
10399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10400       };
10401     } catch (...) {
10402       {
10403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10404       };
10405     }
10406   }
10407 }
10408
10409
10410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10411   void * jresult ;
10412   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10413   Dali::Quaternion result;
10414
10415   arg1 = (Dali::Quaternion *)jarg1;
10416   {
10417     try {
10418       result = ((Dali::Quaternion const *)arg1)->Normalized();
10419     } catch (std::out_of_range& e) {
10420       {
10421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10422       };
10423     } catch (std::exception& e) {
10424       {
10425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10426       };
10427     } catch (...) {
10428       {
10429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10430       };
10431     }
10432   }
10433   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10434   return jresult;
10435 }
10436
10437
10438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10439   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10440
10441   arg1 = (Dali::Quaternion *)jarg1;
10442   {
10443     try {
10444       (arg1)->Conjugate();
10445     } catch (std::out_of_range& e) {
10446       {
10447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10448       };
10449     } catch (std::exception& e) {
10450       {
10451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10452       };
10453     } catch (...) {
10454       {
10455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10456       };
10457     }
10458   }
10459 }
10460
10461
10462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10463   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10464
10465   arg1 = (Dali::Quaternion *)jarg1;
10466   {
10467     try {
10468       (arg1)->Invert();
10469     } catch (std::out_of_range& e) {
10470       {
10471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10472       };
10473     } catch (std::exception& e) {
10474       {
10475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10476       };
10477     } catch (...) {
10478       {
10479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10480       };
10481     }
10482   }
10483 }
10484
10485
10486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10487   void * jresult ;
10488   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10489   Dali::Quaternion result;
10490
10491   arg1 = (Dali::Quaternion *)jarg1;
10492   {
10493     try {
10494       result = ((Dali::Quaternion const *)arg1)->Log();
10495     } catch (std::out_of_range& e) {
10496       {
10497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10498       };
10499     } catch (std::exception& e) {
10500       {
10501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10502       };
10503     } catch (...) {
10504       {
10505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10506       };
10507     }
10508   }
10509   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10510   return jresult;
10511 }
10512
10513
10514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10515   void * jresult ;
10516   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10517   Dali::Quaternion result;
10518
10519   arg1 = (Dali::Quaternion *)jarg1;
10520   {
10521     try {
10522       result = ((Dali::Quaternion const *)arg1)->Exp();
10523     } catch (std::out_of_range& e) {
10524       {
10525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10526       };
10527     } catch (std::exception& e) {
10528       {
10529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10530       };
10531     } catch (...) {
10532       {
10533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10534       };
10535     }
10536   }
10537   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10538   return jresult;
10539 }
10540
10541
10542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10543   float jresult ;
10544   Dali::Quaternion *arg1 = 0 ;
10545   Dali::Quaternion *arg2 = 0 ;
10546   float result;
10547
10548   arg1 = (Dali::Quaternion *)jarg1;
10549   if (!arg1) {
10550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10551     return 0;
10552   }
10553   arg2 = (Dali::Quaternion *)jarg2;
10554   if (!arg2) {
10555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10556     return 0;
10557   }
10558   {
10559     try {
10560       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10568       };
10569     } catch (...) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10572       };
10573     }
10574   }
10575   jresult = result;
10576   return jresult;
10577 }
10578
10579
10580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10581   void * jresult ;
10582   Dali::Quaternion *arg1 = 0 ;
10583   Dali::Quaternion *arg2 = 0 ;
10584   float arg3 ;
10585   Dali::Quaternion result;
10586
10587   arg1 = (Dali::Quaternion *)jarg1;
10588   if (!arg1) {
10589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10590     return 0;
10591   }
10592   arg2 = (Dali::Quaternion *)jarg2;
10593   if (!arg2) {
10594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10595     return 0;
10596   }
10597   arg3 = (float)jarg3;
10598   {
10599     try {
10600       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10601     } catch (std::out_of_range& e) {
10602       {
10603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10604       };
10605     } catch (std::exception& e) {
10606       {
10607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10608       };
10609     } catch (...) {
10610       {
10611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10612       };
10613     }
10614   }
10615   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10616   return jresult;
10617 }
10618
10619
10620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10621   void * jresult ;
10622   Dali::Quaternion *arg1 = 0 ;
10623   Dali::Quaternion *arg2 = 0 ;
10624   float arg3 ;
10625   Dali::Quaternion result;
10626
10627   arg1 = (Dali::Quaternion *)jarg1;
10628   if (!arg1) {
10629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10630     return 0;
10631   }
10632   arg2 = (Dali::Quaternion *)jarg2;
10633   if (!arg2) {
10634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10635     return 0;
10636   }
10637   arg3 = (float)jarg3;
10638   {
10639     try {
10640       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10641     } catch (std::out_of_range& e) {
10642       {
10643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10644       };
10645     } catch (std::exception& e) {
10646       {
10647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10648       };
10649     } catch (...) {
10650       {
10651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10652       };
10653     }
10654   }
10655   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10656   return jresult;
10657 }
10658
10659
10660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10661   void * jresult ;
10662   Dali::Quaternion *arg1 = 0 ;
10663   Dali::Quaternion *arg2 = 0 ;
10664   float arg3 ;
10665   Dali::Quaternion result;
10666
10667   arg1 = (Dali::Quaternion *)jarg1;
10668   if (!arg1) {
10669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10670     return 0;
10671   }
10672   arg2 = (Dali::Quaternion *)jarg2;
10673   if (!arg2) {
10674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10675     return 0;
10676   }
10677   arg3 = (float)jarg3;
10678   {
10679     try {
10680       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10681     } catch (std::out_of_range& e) {
10682       {
10683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10684       };
10685     } catch (std::exception& e) {
10686       {
10687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10688       };
10689     } catch (...) {
10690       {
10691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10692       };
10693     }
10694   }
10695   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10696   return jresult;
10697 }
10698
10699
10700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10701   void * jresult ;
10702   Dali::Quaternion *arg1 = 0 ;
10703   Dali::Quaternion *arg2 = 0 ;
10704   Dali::Quaternion *arg3 = 0 ;
10705   Dali::Quaternion *arg4 = 0 ;
10706   float arg5 ;
10707   Dali::Quaternion result;
10708
10709   arg1 = (Dali::Quaternion *)jarg1;
10710   if (!arg1) {
10711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10712     return 0;
10713   }
10714   arg2 = (Dali::Quaternion *)jarg2;
10715   if (!arg2) {
10716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10717     return 0;
10718   }
10719   arg3 = (Dali::Quaternion *)jarg3;
10720   if (!arg3) {
10721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10722     return 0;
10723   }
10724   arg4 = (Dali::Quaternion *)jarg4;
10725   if (!arg4) {
10726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10727     return 0;
10728   }
10729   arg5 = (float)jarg5;
10730   {
10731     try {
10732       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10733     } catch (std::out_of_range& e) {
10734       {
10735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10736       };
10737     } catch (std::exception& e) {
10738       {
10739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10740       };
10741     } catch (...) {
10742       {
10743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10744       };
10745     }
10746   }
10747   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10748   return jresult;
10749 }
10750
10751
10752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10753   float jresult ;
10754   Dali::Quaternion *arg1 = 0 ;
10755   Dali::Quaternion *arg2 = 0 ;
10756   float result;
10757
10758   arg1 = (Dali::Quaternion *)jarg1;
10759   if (!arg1) {
10760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10761     return 0;
10762   }
10763   arg2 = (Dali::Quaternion *)jarg2;
10764   if (!arg2) {
10765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10766     return 0;
10767   }
10768   {
10769     try {
10770       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10771     } catch (std::out_of_range& e) {
10772       {
10773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10774       };
10775     } catch (std::exception& e) {
10776       {
10777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10778       };
10779     } catch (...) {
10780       {
10781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10782       };
10783     }
10784   }
10785   jresult = result;
10786   return jresult;
10787 }
10788
10789
10790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10791   void * jresult ;
10792   Dali::Matrix *result = 0 ;
10793
10794   {
10795     try {
10796       result = (Dali::Matrix *)new Dali::Matrix();
10797     } catch (std::out_of_range& e) {
10798       {
10799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10800       };
10801     } catch (std::exception& e) {
10802       {
10803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10804       };
10805     } catch (...) {
10806       {
10807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10808       };
10809     }
10810   }
10811   jresult = (void *)result;
10812   return jresult;
10813 }
10814
10815
10816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10817   void * jresult ;
10818   bool arg1 ;
10819   Dali::Matrix *result = 0 ;
10820
10821   arg1 = jarg1 ? true : false;
10822   {
10823     try {
10824       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10825     } catch (std::out_of_range& e) {
10826       {
10827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10828       };
10829     } catch (std::exception& e) {
10830       {
10831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (...) {
10834       {
10835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10836       };
10837     }
10838   }
10839   jresult = (void *)result;
10840   return jresult;
10841 }
10842
10843
10844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10845   void * jresult ;
10846   float *arg1 = (float *) 0 ;
10847   Dali::Matrix *result = 0 ;
10848
10849   arg1 = jarg1;
10850   {
10851     try {
10852       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10853     } catch (std::out_of_range& e) {
10854       {
10855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10856       };
10857     } catch (std::exception& e) {
10858       {
10859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10860       };
10861     } catch (...) {
10862       {
10863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10864       };
10865     }
10866   }
10867   jresult = (void *)result;
10868
10869
10870   return jresult;
10871 }
10872
10873
10874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10875   void * jresult ;
10876   Dali::Quaternion *arg1 = 0 ;
10877   Dali::Matrix *result = 0 ;
10878
10879   arg1 = (Dali::Quaternion *)jarg1;
10880   if (!arg1) {
10881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10882     return 0;
10883   }
10884   {
10885     try {
10886       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10887     } catch (std::out_of_range& e) {
10888       {
10889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10890       };
10891     } catch (std::exception& e) {
10892       {
10893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10894       };
10895     } catch (...) {
10896       {
10897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10898       };
10899     }
10900   }
10901   jresult = (void *)result;
10902   return jresult;
10903 }
10904
10905
10906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10907   void * jresult ;
10908   Dali::Matrix *arg1 = 0 ;
10909   Dali::Matrix *result = 0 ;
10910
10911   arg1 = (Dali::Matrix *)jarg1;
10912   if (!arg1) {
10913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10914     return 0;
10915   }
10916   {
10917     try {
10918       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10919     } catch (std::out_of_range& e) {
10920       {
10921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10922       };
10923     } catch (std::exception& e) {
10924       {
10925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10926       };
10927     } catch (...) {
10928       {
10929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10930       };
10931     }
10932   }
10933   jresult = (void *)result;
10934   return jresult;
10935 }
10936
10937
10938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10939   void * jresult ;
10940   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10941   Dali::Matrix *arg2 = 0 ;
10942   Dali::Matrix *result = 0 ;
10943
10944   arg1 = (Dali::Matrix *)jarg1;
10945   arg2 = (Dali::Matrix *)jarg2;
10946   if (!arg2) {
10947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10948     return 0;
10949   }
10950   {
10951     try {
10952       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10953     } catch (std::out_of_range& e) {
10954       {
10955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10956       };
10957     } catch (std::exception& e) {
10958       {
10959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10960       };
10961     } catch (...) {
10962       {
10963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10964       };
10965     }
10966   }
10967   jresult = (void *)result;
10968   return jresult;
10969 }
10970
10971
10972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
10973   void * jresult ;
10974   Dali::Matrix *result = 0 ;
10975
10976   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
10977   jresult = (void *)result;
10978   return jresult;
10979 }
10980
10981
10982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
10983   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10984
10985   arg1 = (Dali::Matrix *)jarg1;
10986   {
10987     try {
10988       (arg1)->SetIdentity();
10989     } catch (std::out_of_range& e) {
10990       {
10991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10992       };
10993     } catch (std::exception& e) {
10994       {
10995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10996       };
10997     } catch (...) {
10998       {
10999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11000       };
11001     }
11002   }
11003 }
11004
11005
11006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11007   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11008   Dali::Vector3 *arg2 = 0 ;
11009
11010   arg1 = (Dali::Matrix *)jarg1;
11011   arg2 = (Dali::Vector3 *)jarg2;
11012   if (!arg2) {
11013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11014     return ;
11015   }
11016   {
11017     try {
11018       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11019     } catch (std::out_of_range& e) {
11020       {
11021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11022       };
11023     } catch (std::exception& e) {
11024       {
11025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11026       };
11027     } catch (...) {
11028       {
11029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11030       };
11031     }
11032   }
11033 }
11034
11035
11036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11037   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11038   Dali::Matrix *arg2 = 0 ;
11039
11040   arg1 = (Dali::Matrix *)jarg1;
11041   arg2 = (Dali::Matrix *)jarg2;
11042   if (!arg2) {
11043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11044     return ;
11045   }
11046   {
11047     try {
11048       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11049     } catch (std::out_of_range& e) {
11050       {
11051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11052       };
11053     } catch (std::exception& e) {
11054       {
11055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11056       };
11057     } catch (...) {
11058       {
11059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11060       };
11061     }
11062   }
11063 }
11064
11065
11066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11067   unsigned int jresult ;
11068   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11069   bool result;
11070
11071   arg1 = (Dali::Matrix *)jarg1;
11072   {
11073     try {
11074       result = (bool)(arg1)->Invert();
11075     } catch (std::out_of_range& e) {
11076       {
11077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11078       };
11079     } catch (std::exception& e) {
11080       {
11081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11082       };
11083     } catch (...) {
11084       {
11085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11086       };
11087     }
11088   }
11089   jresult = result;
11090   return jresult;
11091 }
11092
11093
11094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11095   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11096
11097   arg1 = (Dali::Matrix *)jarg1;
11098   {
11099     try {
11100       (arg1)->Transpose();
11101     } catch (std::out_of_range& e) {
11102       {
11103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11104       };
11105     } catch (std::exception& e) {
11106       {
11107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11108       };
11109     } catch (...) {
11110       {
11111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11112       };
11113     }
11114   }
11115 }
11116
11117
11118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11119   void * jresult ;
11120   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11121   Dali::Vector3 result;
11122
11123   arg1 = (Dali::Matrix *)jarg1;
11124   {
11125     try {
11126       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11127     } catch (std::out_of_range& e) {
11128       {
11129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11130       };
11131     } catch (std::exception& e) {
11132       {
11133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11134       };
11135     } catch (...) {
11136       {
11137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11138       };
11139     }
11140   }
11141   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11142   return jresult;
11143 }
11144
11145
11146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11147   void * jresult ;
11148   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11149   Dali::Vector3 result;
11150
11151   arg1 = (Dali::Matrix *)jarg1;
11152   {
11153     try {
11154       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11155     } catch (std::out_of_range& e) {
11156       {
11157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11158       };
11159     } catch (std::exception& e) {
11160       {
11161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11162       };
11163     } catch (...) {
11164       {
11165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11166       };
11167     }
11168   }
11169   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11170   return jresult;
11171 }
11172
11173
11174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11175   void * jresult ;
11176   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11177   Dali::Vector3 result;
11178
11179   arg1 = (Dali::Matrix *)jarg1;
11180   {
11181     try {
11182       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11183     } catch (std::out_of_range& e) {
11184       {
11185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11186       };
11187     } catch (std::exception& e) {
11188       {
11189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11190       };
11191     } catch (...) {
11192       {
11193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11194       };
11195     }
11196   }
11197   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11198   return jresult;
11199 }
11200
11201
11202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11203   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11204   Dali::Vector3 *arg2 = 0 ;
11205
11206   arg1 = (Dali::Matrix *)jarg1;
11207   arg2 = (Dali::Vector3 *)jarg2;
11208   if (!arg2) {
11209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11210     return ;
11211   }
11212   {
11213     try {
11214       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11215     } catch (std::out_of_range& e) {
11216       {
11217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11218       };
11219     } catch (std::exception& e) {
11220       {
11221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11222       };
11223     } catch (...) {
11224       {
11225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11226       };
11227     }
11228   }
11229 }
11230
11231
11232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11233   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11234   Dali::Vector3 *arg2 = 0 ;
11235
11236   arg1 = (Dali::Matrix *)jarg1;
11237   arg2 = (Dali::Vector3 *)jarg2;
11238   if (!arg2) {
11239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11240     return ;
11241   }
11242   {
11243     try {
11244       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11245     } catch (std::out_of_range& e) {
11246       {
11247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11248       };
11249     } catch (std::exception& e) {
11250       {
11251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11252       };
11253     } catch (...) {
11254       {
11255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11256       };
11257     }
11258   }
11259 }
11260
11261
11262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11263   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11264   Dali::Vector3 *arg2 = 0 ;
11265
11266   arg1 = (Dali::Matrix *)jarg1;
11267   arg2 = (Dali::Vector3 *)jarg2;
11268   if (!arg2) {
11269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11270     return ;
11271   }
11272   {
11273     try {
11274       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11275     } catch (std::out_of_range& e) {
11276       {
11277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11278       };
11279     } catch (std::exception& e) {
11280       {
11281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11282       };
11283     } catch (...) {
11284       {
11285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11286       };
11287     }
11288   }
11289 }
11290
11291
11292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11293   void * jresult ;
11294   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11295   Dali::Vector4 *result = 0 ;
11296
11297   arg1 = (Dali::Matrix *)jarg1;
11298   {
11299     try {
11300       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11301     } catch (std::out_of_range& e) {
11302       {
11303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11304       };
11305     } catch (std::exception& e) {
11306       {
11307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11308       };
11309     } catch (...) {
11310       {
11311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11312       };
11313     }
11314   }
11315   jresult = (void *)result;
11316   return jresult;
11317 }
11318
11319
11320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11321   void * jresult ;
11322   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11323   Dali::Vector3 *result = 0 ;
11324
11325   arg1 = (Dali::Matrix *)jarg1;
11326   {
11327     try {
11328       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11329     } catch (std::out_of_range& e) {
11330       {
11331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11332       };
11333     } catch (std::exception& e) {
11334       {
11335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11336       };
11337     } catch (...) {
11338       {
11339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11340       };
11341     }
11342   }
11343   jresult = (void *)result;
11344   return jresult;
11345 }
11346
11347
11348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11349   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11350   Dali::Vector4 *arg2 = 0 ;
11351
11352   arg1 = (Dali::Matrix *)jarg1;
11353   arg2 = (Dali::Vector4 *)jarg2;
11354   if (!arg2) {
11355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11356     return ;
11357   }
11358   {
11359     try {
11360       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11361     } catch (std::out_of_range& e) {
11362       {
11363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11364       };
11365     } catch (std::exception& e) {
11366       {
11367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11368       };
11369     } catch (...) {
11370       {
11371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11372       };
11373     }
11374   }
11375 }
11376
11377
11378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11379   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11380   Dali::Vector3 *arg2 = 0 ;
11381
11382   arg1 = (Dali::Matrix *)jarg1;
11383   arg2 = (Dali::Vector3 *)jarg2;
11384   if (!arg2) {
11385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11386     return ;
11387   }
11388   {
11389     try {
11390       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11391     } catch (std::out_of_range& e) {
11392       {
11393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11394       };
11395     } catch (std::exception& e) {
11396       {
11397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11398       };
11399     } catch (...) {
11400       {
11401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11402       };
11403     }
11404   }
11405 }
11406
11407
11408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11409   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11410
11411   arg1 = (Dali::Matrix *)jarg1;
11412   {
11413     try {
11414       (arg1)->OrthoNormalize();
11415     } catch (std::out_of_range& e) {
11416       {
11417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11418       };
11419     } catch (std::exception& e) {
11420       {
11421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11422       };
11423     } catch (...) {
11424       {
11425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11426       };
11427     }
11428   }
11429 }
11430
11431
11432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11433   void * jresult ;
11434   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11435   float *result = 0 ;
11436
11437   arg1 = (Dali::Matrix *)jarg1;
11438   {
11439     try {
11440       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11441     } catch (std::out_of_range& e) {
11442       {
11443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11444       };
11445     } catch (std::exception& e) {
11446       {
11447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11448       };
11449     } catch (...) {
11450       {
11451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11452       };
11453     }
11454   }
11455   jresult = (void *)result;
11456   return jresult;
11457 }
11458
11459
11460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11461   Dali::Matrix *arg1 = 0 ;
11462   Dali::Matrix *arg2 = 0 ;
11463   Dali::Matrix *arg3 = 0 ;
11464
11465   arg1 = (Dali::Matrix *)jarg1;
11466   if (!arg1) {
11467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11468     return ;
11469   }
11470   arg2 = (Dali::Matrix *)jarg2;
11471   if (!arg2) {
11472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11473     return ;
11474   }
11475   arg3 = (Dali::Matrix *)jarg3;
11476   if (!arg3) {
11477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11478     return ;
11479   }
11480   {
11481     try {
11482       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11483     } catch (std::out_of_range& e) {
11484       {
11485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11486       };
11487     } catch (std::exception& e) {
11488       {
11489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11490       };
11491     } catch (...) {
11492       {
11493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11494       };
11495     }
11496   }
11497 }
11498
11499
11500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11501   Dali::Matrix *arg1 = 0 ;
11502   Dali::Matrix *arg2 = 0 ;
11503   Dali::Quaternion *arg3 = 0 ;
11504
11505   arg1 = (Dali::Matrix *)jarg1;
11506   if (!arg1) {
11507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11508     return ;
11509   }
11510   arg2 = (Dali::Matrix *)jarg2;
11511   if (!arg2) {
11512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11513     return ;
11514   }
11515   arg3 = (Dali::Quaternion *)jarg3;
11516   if (!arg3) {
11517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11518     return ;
11519   }
11520   {
11521     try {
11522       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11523     } catch (std::out_of_range& e) {
11524       {
11525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11526       };
11527     } catch (std::exception& e) {
11528       {
11529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11530       };
11531     } catch (...) {
11532       {
11533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11534       };
11535     }
11536   }
11537 }
11538
11539
11540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11541   void * jresult ;
11542   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11543   Dali::Vector4 *arg2 = 0 ;
11544   Dali::Vector4 result;
11545
11546   arg1 = (Dali::Matrix *)jarg1;
11547   arg2 = (Dali::Vector4 *)jarg2;
11548   if (!arg2) {
11549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11550     return 0;
11551   }
11552   {
11553     try {
11554       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11555     } catch (std::out_of_range& e) {
11556       {
11557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11558       };
11559     } catch (std::exception& e) {
11560       {
11561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11562       };
11563     } catch (...) {
11564       {
11565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11566       };
11567     }
11568   }
11569   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11570   return jresult;
11571 }
11572
11573
11574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11575   unsigned int jresult ;
11576   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11577   Dali::Matrix *arg2 = 0 ;
11578   bool result;
11579
11580   arg1 = (Dali::Matrix *)jarg1;
11581   arg2 = (Dali::Matrix *)jarg2;
11582   if (!arg2) {
11583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11584     return 0;
11585   }
11586   {
11587     try {
11588       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11589     } catch (std::out_of_range& e) {
11590       {
11591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11592       };
11593     } catch (std::exception& e) {
11594       {
11595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11596       };
11597     } catch (...) {
11598       {
11599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11600       };
11601     }
11602   }
11603   jresult = result;
11604   return jresult;
11605 }
11606
11607
11608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11609   unsigned int jresult ;
11610   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11611   Dali::Matrix *arg2 = 0 ;
11612   bool result;
11613
11614   arg1 = (Dali::Matrix *)jarg1;
11615   arg2 = (Dali::Matrix *)jarg2;
11616   if (!arg2) {
11617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11618     return 0;
11619   }
11620   {
11621     try {
11622       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11623     } catch (std::out_of_range& e) {
11624       {
11625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11626       };
11627     } catch (std::exception& e) {
11628       {
11629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11630       };
11631     } catch (...) {
11632       {
11633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11634       };
11635     }
11636   }
11637   jresult = result;
11638   return jresult;
11639 }
11640
11641
11642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11643   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11644   Dali::Vector3 *arg2 = 0 ;
11645   Dali::Quaternion *arg3 = 0 ;
11646   Dali::Vector3 *arg4 = 0 ;
11647
11648   arg1 = (Dali::Matrix *)jarg1;
11649   arg2 = (Dali::Vector3 *)jarg2;
11650   if (!arg2) {
11651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11652     return ;
11653   }
11654   arg3 = (Dali::Quaternion *)jarg3;
11655   if (!arg3) {
11656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11657     return ;
11658   }
11659   arg4 = (Dali::Vector3 *)jarg4;
11660   if (!arg4) {
11661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11662     return ;
11663   }
11664   {
11665     try {
11666       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11667     } catch (std::out_of_range& e) {
11668       {
11669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11670       };
11671     } catch (std::exception& e) {
11672       {
11673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11674       };
11675     } catch (...) {
11676       {
11677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11678       };
11679     }
11680   }
11681 }
11682
11683
11684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11685   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11686   Dali::Vector3 *arg2 = 0 ;
11687   Dali::Quaternion *arg3 = 0 ;
11688   Dali::Vector3 *arg4 = 0 ;
11689
11690   arg1 = (Dali::Matrix *)jarg1;
11691   arg2 = (Dali::Vector3 *)jarg2;
11692   if (!arg2) {
11693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11694     return ;
11695   }
11696   arg3 = (Dali::Quaternion *)jarg3;
11697   if (!arg3) {
11698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11699     return ;
11700   }
11701   arg4 = (Dali::Vector3 *)jarg4;
11702   if (!arg4) {
11703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11704     return ;
11705   }
11706   {
11707     try {
11708       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11709     } catch (std::out_of_range& e) {
11710       {
11711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11712       };
11713     } catch (std::exception& e) {
11714       {
11715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11716       };
11717     } catch (...) {
11718       {
11719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11720       };
11721     }
11722   }
11723 }
11724
11725
11726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11727   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11728   Dali::Vector3 *arg2 = 0 ;
11729   Dali::Vector3 *arg3 = 0 ;
11730   Dali::Vector3 *arg4 = 0 ;
11731   Dali::Vector3 *arg5 = 0 ;
11732
11733   arg1 = (Dali::Matrix *)jarg1;
11734   arg2 = (Dali::Vector3 *)jarg2;
11735   if (!arg2) {
11736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11737     return ;
11738   }
11739   arg3 = (Dali::Vector3 *)jarg3;
11740   if (!arg3) {
11741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11742     return ;
11743   }
11744   arg4 = (Dali::Vector3 *)jarg4;
11745   if (!arg4) {
11746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11747     return ;
11748   }
11749   arg5 = (Dali::Vector3 *)jarg5;
11750   if (!arg5) {
11751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11752     return ;
11753   }
11754   {
11755     try {
11756       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11757     } catch (std::out_of_range& e) {
11758       {
11759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11760       };
11761     } catch (std::exception& e) {
11762       {
11763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11764       };
11765     } catch (...) {
11766       {
11767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11768       };
11769     }
11770   }
11771 }
11772
11773
11774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11775   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11776   Dali::Vector3 *arg2 = 0 ;
11777   Dali::Quaternion *arg3 = 0 ;
11778   Dali::Vector3 *arg4 = 0 ;
11779
11780   arg1 = (Dali::Matrix *)jarg1;
11781   arg2 = (Dali::Vector3 *)jarg2;
11782   if (!arg2) {
11783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11784     return ;
11785   }
11786   arg3 = (Dali::Quaternion *)jarg3;
11787   if (!arg3) {
11788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11789     return ;
11790   }
11791   arg4 = (Dali::Vector3 *)jarg4;
11792   if (!arg4) {
11793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11794     return ;
11795   }
11796   {
11797     try {
11798       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11799     } catch (std::out_of_range& e) {
11800       {
11801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11802       };
11803     } catch (std::exception& e) {
11804       {
11805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11806       };
11807     } catch (...) {
11808       {
11809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11810       };
11811     }
11812   }
11813 }
11814
11815
11816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11817   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11818
11819   arg1 = (Dali::Matrix *)jarg1;
11820   {
11821     try {
11822       delete arg1;
11823     } catch (std::out_of_range& e) {
11824       {
11825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11826       };
11827     } catch (std::exception& e) {
11828       {
11829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11830       };
11831     } catch (...) {
11832       {
11833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11834       };
11835     }
11836   }
11837 }
11838
11839
11840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11841   void * jresult ;
11842   Dali::Matrix3 *result = 0 ;
11843
11844   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11845   jresult = (void *)result;
11846   return jresult;
11847 }
11848
11849
11850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11851   void * jresult ;
11852   Dali::Matrix3 *result = 0 ;
11853
11854   {
11855     try {
11856       result = (Dali::Matrix3 *)new Dali::Matrix3();
11857     } catch (std::out_of_range& e) {
11858       {
11859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11860       };
11861     } catch (std::exception& e) {
11862       {
11863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11864       };
11865     } catch (...) {
11866       {
11867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11868       };
11869     }
11870   }
11871   jresult = (void *)result;
11872   return jresult;
11873 }
11874
11875
11876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11877   void * jresult ;
11878   Dali::Matrix3 *arg1 = 0 ;
11879   Dali::Matrix3 *result = 0 ;
11880
11881   arg1 = (Dali::Matrix3 *)jarg1;
11882   if (!arg1) {
11883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11884     return 0;
11885   }
11886   {
11887     try {
11888       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11889     } catch (std::out_of_range& e) {
11890       {
11891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11892       };
11893     } catch (std::exception& e) {
11894       {
11895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11896       };
11897     } catch (...) {
11898       {
11899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11900       };
11901     }
11902   }
11903   jresult = (void *)result;
11904   return jresult;
11905 }
11906
11907
11908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11909   void * jresult ;
11910   Dali::Matrix *arg1 = 0 ;
11911   Dali::Matrix3 *result = 0 ;
11912
11913   arg1 = (Dali::Matrix *)jarg1;
11914   if (!arg1) {
11915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11916     return 0;
11917   }
11918   {
11919     try {
11920       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11921     } catch (std::out_of_range& e) {
11922       {
11923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (std::exception& e) {
11926       {
11927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11928       };
11929     } catch (...) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11932       };
11933     }
11934   }
11935   jresult = (void *)result;
11936   return jresult;
11937 }
11938
11939
11940 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) {
11941   void * jresult ;
11942   float arg1 ;
11943   float arg2 ;
11944   float arg3 ;
11945   float arg4 ;
11946   float arg5 ;
11947   float arg6 ;
11948   float arg7 ;
11949   float arg8 ;
11950   float arg9 ;
11951   Dali::Matrix3 *result = 0 ;
11952
11953   arg1 = (float)jarg1;
11954   arg2 = (float)jarg2;
11955   arg3 = (float)jarg3;
11956   arg4 = (float)jarg4;
11957   arg5 = (float)jarg5;
11958   arg6 = (float)jarg6;
11959   arg7 = (float)jarg7;
11960   arg8 = (float)jarg8;
11961   arg9 = (float)jarg9;
11962   {
11963     try {
11964       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11965     } catch (std::out_of_range& e) {
11966       {
11967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11968       };
11969     } catch (std::exception& e) {
11970       {
11971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11972       };
11973     } catch (...) {
11974       {
11975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11976       };
11977     }
11978   }
11979   jresult = (void *)result;
11980   return jresult;
11981 }
11982
11983
11984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
11985   void * jresult ;
11986   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
11987   Dali::Matrix3 *arg2 = 0 ;
11988   Dali::Matrix3 *result = 0 ;
11989
11990   arg1 = (Dali::Matrix3 *)jarg1;
11991   arg2 = (Dali::Matrix3 *)jarg2;
11992   if (!arg2) {
11993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11994     return 0;
11995   }
11996   {
11997     try {
11998       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
11999     } catch (std::out_of_range& e) {
12000       {
12001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12002       };
12003     } catch (std::exception& e) {
12004       {
12005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12006       };
12007     } catch (...) {
12008       {
12009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12010       };
12011     }
12012   }
12013   jresult = (void *)result;
12014   return jresult;
12015 }
12016
12017
12018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12019   void * jresult ;
12020   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12021   Dali::Matrix *arg2 = 0 ;
12022   Dali::Matrix3 *result = 0 ;
12023
12024   arg1 = (Dali::Matrix3 *)jarg1;
12025   arg2 = (Dali::Matrix *)jarg2;
12026   if (!arg2) {
12027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12028     return 0;
12029   }
12030   {
12031     try {
12032       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12033     } catch (std::out_of_range& e) {
12034       {
12035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12036       };
12037     } catch (std::exception& e) {
12038       {
12039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12040       };
12041     } catch (...) {
12042       {
12043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12044       };
12045     }
12046   }
12047   jresult = (void *)result;
12048   return jresult;
12049 }
12050
12051
12052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12053   unsigned int jresult ;
12054   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12055   Dali::Matrix3 *arg2 = 0 ;
12056   bool result;
12057
12058   arg1 = (Dali::Matrix3 *)jarg1;
12059   arg2 = (Dali::Matrix3 *)jarg2;
12060   if (!arg2) {
12061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12062     return 0;
12063   }
12064   {
12065     try {
12066       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12067     } catch (std::out_of_range& e) {
12068       {
12069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12070       };
12071     } catch (std::exception& e) {
12072       {
12073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12074       };
12075     } catch (...) {
12076       {
12077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12078       };
12079     }
12080   }
12081   jresult = result;
12082   return jresult;
12083 }
12084
12085
12086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12087   unsigned int jresult ;
12088   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12089   Dali::Matrix3 *arg2 = 0 ;
12090   bool result;
12091
12092   arg1 = (Dali::Matrix3 *)jarg1;
12093   arg2 = (Dali::Matrix3 *)jarg2;
12094   if (!arg2) {
12095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12096     return 0;
12097   }
12098   {
12099     try {
12100       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12101     } catch (std::out_of_range& e) {
12102       {
12103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12104       };
12105     } catch (std::exception& e) {
12106       {
12107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12108       };
12109     } catch (...) {
12110       {
12111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12112       };
12113     }
12114   }
12115   jresult = result;
12116   return jresult;
12117 }
12118
12119
12120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12121   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12122
12123   arg1 = (Dali::Matrix3 *)jarg1;
12124   {
12125     try {
12126       delete arg1;
12127     } catch (std::out_of_range& e) {
12128       {
12129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12130       };
12131     } catch (std::exception& e) {
12132       {
12133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12134       };
12135     } catch (...) {
12136       {
12137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12138       };
12139     }
12140   }
12141 }
12142
12143
12144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12145   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12146
12147   arg1 = (Dali::Matrix3 *)jarg1;
12148   {
12149     try {
12150       (arg1)->SetIdentity();
12151     } catch (std::out_of_range& e) {
12152       {
12153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12154       };
12155     } catch (std::exception& e) {
12156       {
12157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12158       };
12159     } catch (...) {
12160       {
12161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12162       };
12163     }
12164   }
12165 }
12166
12167
12168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12169   void * jresult ;
12170   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12171   float *result = 0 ;
12172
12173   arg1 = (Dali::Matrix3 *)jarg1;
12174   {
12175     try {
12176       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12177     } catch (std::out_of_range& e) {
12178       {
12179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12180       };
12181     } catch (std::exception& e) {
12182       {
12183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12184       };
12185     } catch (...) {
12186       {
12187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12188       };
12189     }
12190   }
12191   jresult = (void *)result;
12192   return jresult;
12193 }
12194
12195
12196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12197   unsigned int jresult ;
12198   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12199   bool result;
12200
12201   arg1 = (Dali::Matrix3 *)jarg1;
12202   {
12203     try {
12204       result = (bool)(arg1)->Invert();
12205     } catch (std::out_of_range& e) {
12206       {
12207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12208       };
12209     } catch (std::exception& e) {
12210       {
12211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12212       };
12213     } catch (...) {
12214       {
12215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12216       };
12217     }
12218   }
12219   jresult = result;
12220   return jresult;
12221 }
12222
12223
12224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12225   unsigned int jresult ;
12226   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12227   bool result;
12228
12229   arg1 = (Dali::Matrix3 *)jarg1;
12230   {
12231     try {
12232       result = (bool)(arg1)->Transpose();
12233     } catch (std::out_of_range& e) {
12234       {
12235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12236       };
12237     } catch (std::exception& e) {
12238       {
12239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12240       };
12241     } catch (...) {
12242       {
12243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12244       };
12245     }
12246   }
12247   jresult = result;
12248   return jresult;
12249 }
12250
12251
12252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12253   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12254   float arg2 ;
12255
12256   arg1 = (Dali::Matrix3 *)jarg1;
12257   arg2 = (float)jarg2;
12258   {
12259     try {
12260       (arg1)->Scale(arg2);
12261     } catch (std::out_of_range& e) {
12262       {
12263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12264       };
12265     } catch (std::exception& e) {
12266       {
12267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12268       };
12269     } catch (...) {
12270       {
12271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12272       };
12273     }
12274   }
12275 }
12276
12277
12278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12279   float jresult ;
12280   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12281   float result;
12282
12283   arg1 = (Dali::Matrix3 *)jarg1;
12284   {
12285     try {
12286       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12287     } catch (std::out_of_range& e) {
12288       {
12289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12290       };
12291     } catch (std::exception& e) {
12292       {
12293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12294       };
12295     } catch (...) {
12296       {
12297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12298       };
12299     }
12300   }
12301   jresult = result;
12302   return jresult;
12303 }
12304
12305
12306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12307   unsigned int jresult ;
12308   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12309   bool result;
12310
12311   arg1 = (Dali::Matrix3 *)jarg1;
12312   {
12313     try {
12314       result = (bool)(arg1)->ScaledInverseTranspose();
12315     } catch (std::out_of_range& e) {
12316       {
12317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12318       };
12319     } catch (std::exception& e) {
12320       {
12321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12322       };
12323     } catch (...) {
12324       {
12325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12326       };
12327     }
12328   }
12329   jresult = result;
12330   return jresult;
12331 }
12332
12333
12334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12335   Dali::Matrix3 *arg1 = 0 ;
12336   Dali::Matrix3 *arg2 = 0 ;
12337   Dali::Matrix3 *arg3 = 0 ;
12338
12339   arg1 = (Dali::Matrix3 *)jarg1;
12340   if (!arg1) {
12341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12342     return ;
12343   }
12344   arg2 = (Dali::Matrix3 *)jarg2;
12345   if (!arg2) {
12346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12347     return ;
12348   }
12349   arg3 = (Dali::Matrix3 *)jarg3;
12350   if (!arg3) {
12351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12352     return ;
12353   }
12354   {
12355     try {
12356       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12357     } catch (std::out_of_range& e) {
12358       {
12359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12360       };
12361     } catch (std::exception& e) {
12362       {
12363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12364       };
12365     } catch (...) {
12366       {
12367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12368       };
12369     }
12370   }
12371 }
12372
12373
12374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12375   float jresult ;
12376   float arg1 ;
12377   float arg2 ;
12378   float result;
12379
12380   arg1 = (float)jarg1;
12381   arg2 = (float)jarg2;
12382   {
12383     try {
12384       result = (float)Dali::Random::Range(arg1,arg2);
12385     } catch (std::out_of_range& e) {
12386       {
12387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12388       };
12389     } catch (std::exception& e) {
12390       {
12391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12392       };
12393     } catch (...) {
12394       {
12395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12396       };
12397     }
12398   }
12399   jresult = result;
12400   return jresult;
12401 }
12402
12403
12404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12405   void * jresult ;
12406   Dali::Vector4 result;
12407
12408   {
12409     try {
12410       result = Dali::Random::Axis();
12411     } catch (std::out_of_range& e) {
12412       {
12413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12414       };
12415     } catch (std::exception& e) {
12416       {
12417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12418       };
12419     } catch (...) {
12420       {
12421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12422       };
12423     }
12424   }
12425   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12426   return jresult;
12427 }
12428
12429
12430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12431   void * jresult ;
12432   Dali::AngleAxis *result = 0 ;
12433
12434   {
12435     try {
12436       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12437     } catch (std::out_of_range& e) {
12438       {
12439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12440       };
12441     } catch (std::exception& e) {
12442       {
12443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12444       };
12445     } catch (...) {
12446       {
12447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12448       };
12449     }
12450   }
12451   jresult = (void *)result;
12452   return jresult;
12453 }
12454
12455
12456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12457   void * jresult ;
12458   Dali::Radian arg1 ;
12459   Dali::Vector3 *arg2 = 0 ;
12460   Dali::Radian *argp1 ;
12461   Dali::AngleAxis *result = 0 ;
12462
12463   argp1 = (Dali::Radian *)jarg1;
12464   if (!argp1) {
12465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12466     return 0;
12467   }
12468   arg1 = *argp1;
12469   arg2 = (Dali::Vector3 *)jarg2;
12470   if (!arg2) {
12471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12472     return 0;
12473   }
12474   {
12475     try {
12476       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12477     } catch (std::out_of_range& e) {
12478       {
12479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12480       };
12481     } catch (std::exception& e) {
12482       {
12483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12484       };
12485     } catch (...) {
12486       {
12487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12488       };
12489     }
12490   }
12491   jresult = (void *)result;
12492   return jresult;
12493 }
12494
12495
12496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12497   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12498   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12499
12500   arg1 = (Dali::AngleAxis *)jarg1;
12501   arg2 = (Dali::Radian *)jarg2;
12502   if (arg1) (arg1)->angle = *arg2;
12503 }
12504
12505
12506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12507   void * jresult ;
12508   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12509   Dali::Radian *result = 0 ;
12510
12511   arg1 = (Dali::AngleAxis *)jarg1;
12512   result = (Dali::Radian *)& ((arg1)->angle);
12513   jresult = (void *)result;
12514   return jresult;
12515 }
12516
12517
12518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12519   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12520   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12521
12522   arg1 = (Dali::AngleAxis *)jarg1;
12523   arg2 = (Dali::Vector3 *)jarg2;
12524   if (arg1) (arg1)->axis = *arg2;
12525 }
12526
12527
12528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12529   void * jresult ;
12530   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12531   Dali::Vector3 *result = 0 ;
12532
12533   arg1 = (Dali::AngleAxis *)jarg1;
12534   result = (Dali::Vector3 *)& ((arg1)->axis);
12535   jresult = (void *)result;
12536   return jresult;
12537 }
12538
12539
12540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12541   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12542
12543   arg1 = (Dali::AngleAxis *)jarg1;
12544   {
12545     try {
12546       delete arg1;
12547     } catch (std::out_of_range& e) {
12548       {
12549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12550       };
12551     } catch (std::exception& e) {
12552       {
12553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12554       };
12555     } catch (...) {
12556       {
12557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12558       };
12559     }
12560   }
12561 }
12562
12563
12564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12565   unsigned int jresult ;
12566   Dali::AngleAxis *arg1 = 0 ;
12567   Dali::AngleAxis *arg2 = 0 ;
12568   bool result;
12569
12570   arg1 = (Dali::AngleAxis *)jarg1;
12571   if (!arg1) {
12572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12573     return 0;
12574   }
12575   arg2 = (Dali::AngleAxis *)jarg2;
12576   if (!arg2) {
12577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12578     return 0;
12579   }
12580   {
12581     try {
12582       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12583     } catch (std::out_of_range& e) {
12584       {
12585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12586       };
12587     } catch (std::exception& e) {
12588       {
12589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12590       };
12591     } catch (...) {
12592       {
12593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12594       };
12595     }
12596   }
12597   jresult = result;
12598   return jresult;
12599 }
12600
12601
12602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12603   unsigned int jresult ;
12604   unsigned int arg1 ;
12605   unsigned int result;
12606
12607   arg1 = (unsigned int)jarg1;
12608   {
12609     try {
12610       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12611     } catch (std::out_of_range& e) {
12612       {
12613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12614       };
12615     } catch (std::exception& e) {
12616       {
12617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12618       };
12619     } catch (...) {
12620       {
12621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12622       };
12623     }
12624   }
12625   jresult = result;
12626   return jresult;
12627 }
12628
12629
12630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12631   unsigned int jresult ;
12632   unsigned int arg1 ;
12633   bool result;
12634
12635   arg1 = (unsigned int)jarg1;
12636   {
12637     try {
12638       result = (bool)Dali::IsPowerOfTwo(arg1);
12639     } catch (std::out_of_range& e) {
12640       {
12641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12642       };
12643     } catch (std::exception& e) {
12644       {
12645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12646       };
12647     } catch (...) {
12648       {
12649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12650       };
12651     }
12652   }
12653   jresult = result;
12654   return jresult;
12655 }
12656
12657
12658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12659   float jresult ;
12660   float arg1 ;
12661   float arg2 ;
12662   float result;
12663
12664   arg1 = (float)jarg1;
12665   arg2 = (float)jarg2;
12666   {
12667     try {
12668       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12669     } catch (std::out_of_range& e) {
12670       {
12671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12672       };
12673     } catch (std::exception& e) {
12674       {
12675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12676       };
12677     } catch (...) {
12678       {
12679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12680       };
12681     }
12682   }
12683   jresult = result;
12684   return jresult;
12685 }
12686
12687
12688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12689   unsigned int jresult ;
12690   float arg1 ;
12691   bool result;
12692
12693   arg1 = (float)jarg1;
12694   {
12695     try {
12696       result = (bool)Dali::EqualsZero(arg1);
12697     } catch (std::out_of_range& e) {
12698       {
12699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12700       };
12701     } catch (std::exception& e) {
12702       {
12703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12704       };
12705     } catch (...) {
12706       {
12707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12708       };
12709     }
12710   }
12711   jresult = result;
12712   return jresult;
12713 }
12714
12715
12716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12717   unsigned int jresult ;
12718   float arg1 ;
12719   float arg2 ;
12720   bool result;
12721
12722   arg1 = (float)jarg1;
12723   arg2 = (float)jarg2;
12724   {
12725     try {
12726       result = (bool)Dali::Equals(arg1,arg2);
12727     } catch (std::out_of_range& e) {
12728       {
12729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12730       };
12731     } catch (std::exception& e) {
12732       {
12733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12734       };
12735     } catch (...) {
12736       {
12737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12738       };
12739     }
12740   }
12741   jresult = result;
12742   return jresult;
12743 }
12744
12745
12746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12747   unsigned int jresult ;
12748   float arg1 ;
12749   float arg2 ;
12750   float arg3 ;
12751   bool result;
12752
12753   arg1 = (float)jarg1;
12754   arg2 = (float)jarg2;
12755   arg3 = (float)jarg3;
12756   {
12757     try {
12758       result = (bool)Dali::Equals(arg1,arg2,arg3);
12759     } catch (std::out_of_range& e) {
12760       {
12761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12762       };
12763     } catch (std::exception& e) {
12764       {
12765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12766       };
12767     } catch (...) {
12768       {
12769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12770       };
12771     }
12772   }
12773   jresult = result;
12774   return jresult;
12775 }
12776
12777
12778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12779   float jresult ;
12780   float arg1 ;
12781   int arg2 ;
12782   float result;
12783
12784   arg1 = (float)jarg1;
12785   arg2 = (int)jarg2;
12786   {
12787     try {
12788       result = (float)Dali::Round(arg1,arg2);
12789     } catch (std::out_of_range& e) {
12790       {
12791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12792       };
12793     } catch (std::exception& e) {
12794       {
12795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12796       };
12797     } catch (...) {
12798       {
12799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12800       };
12801     }
12802   }
12803   jresult = result;
12804   return jresult;
12805 }
12806
12807
12808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12809   float jresult ;
12810   float arg1 ;
12811   float arg2 ;
12812   float arg3 ;
12813   float result;
12814
12815   arg1 = (float)jarg1;
12816   arg2 = (float)jarg2;
12817   arg3 = (float)jarg3;
12818   {
12819     try {
12820       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12821     } catch (std::out_of_range& e) {
12822       {
12823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12824       };
12825     } catch (std::exception& e) {
12826       {
12827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12828       };
12829     } catch (...) {
12830       {
12831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12832       };
12833     }
12834   }
12835   jresult = result;
12836   return jresult;
12837 }
12838
12839
12840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12841   float jresult ;
12842   float arg1 ;
12843   float arg2 ;
12844   float arg3 ;
12845   float arg4 ;
12846   float result;
12847
12848   arg1 = (float)jarg1;
12849   arg2 = (float)jarg2;
12850   arg3 = (float)jarg3;
12851   arg4 = (float)jarg4;
12852   {
12853     try {
12854       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12855     } catch (std::out_of_range& e) {
12856       {
12857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12858       };
12859     } catch (std::exception& e) {
12860       {
12861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12862       };
12863     } catch (...) {
12864       {
12865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12866       };
12867     }
12868   }
12869   jresult = result;
12870   return jresult;
12871 }
12872
12873
12874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12875   int jresult ;
12876   int result;
12877
12878   result = (int)(int)Dali::Property::INVALID_INDEX;
12879   jresult = result;
12880   return jresult;
12881 }
12882
12883
12884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12885   int jresult ;
12886   int result;
12887
12888   result = (int)(int)Dali::Property::INVALID_KEY;
12889   jresult = result;
12890   return jresult;
12891 }
12892
12893
12894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12895   int jresult ;
12896   int result;
12897
12898   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12899   jresult = result;
12900   return jresult;
12901 }
12902
12903
12904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12905   void * jresult ;
12906   Dali::Handle *arg1 = 0 ;
12907   Dali::Property::Index arg2 ;
12908   Dali::Property *result = 0 ;
12909
12910   arg1 = (Dali::Handle *)jarg1;
12911   if (!arg1) {
12912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12913     return 0;
12914   }
12915   arg2 = (Dali::Property::Index)jarg2;
12916   {
12917     try {
12918       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12919     } catch (std::out_of_range& e) {
12920       {
12921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12922       };
12923     } catch (std::exception& e) {
12924       {
12925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12926       };
12927     } catch (...) {
12928       {
12929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12930       };
12931     }
12932   }
12933   jresult = (void *)result;
12934   return jresult;
12935 }
12936
12937
12938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12939   void * jresult ;
12940   Dali::Handle *arg1 = 0 ;
12941   Dali::Property::Index arg2 ;
12942   int arg3 ;
12943   Dali::Property *result = 0 ;
12944
12945   arg1 = (Dali::Handle *)jarg1;
12946   if (!arg1) {
12947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12948     return 0;
12949   }
12950   arg2 = (Dali::Property::Index)jarg2;
12951   arg3 = (int)jarg3;
12952   {
12953     try {
12954       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12955     } catch (std::out_of_range& e) {
12956       {
12957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12958       };
12959     } catch (std::exception& e) {
12960       {
12961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12962       };
12963     } catch (...) {
12964       {
12965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12966       };
12967     }
12968   }
12969   jresult = (void *)result;
12970   return jresult;
12971 }
12972
12973
12974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
12975   void * jresult ;
12976   Dali::Handle *arg1 = 0 ;
12977   std::string *arg2 = 0 ;
12978   Dali::Property *result = 0 ;
12979
12980   arg1 = (Dali::Handle *)jarg1;
12981   if (!arg1) {
12982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12983     return 0;
12984   }
12985   if (!jarg2) {
12986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12987     return 0;
12988   }
12989   std::string arg2_str(jarg2);
12990   arg2 = &arg2_str;
12991   {
12992     try {
12993       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
12994     } catch (std::out_of_range& e) {
12995       {
12996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12997       };
12998     } catch (std::exception& e) {
12999       {
13000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13001       };
13002     } catch (...) {
13003       {
13004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13005       };
13006     }
13007   }
13008   jresult = (void *)result;
13009
13010   //argout typemap for const std::string&
13011
13012   return jresult;
13013 }
13014
13015
13016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13017   void * jresult ;
13018   Dali::Handle *arg1 = 0 ;
13019   std::string *arg2 = 0 ;
13020   int arg3 ;
13021   Dali::Property *result = 0 ;
13022
13023   arg1 = (Dali::Handle *)jarg1;
13024   if (!arg1) {
13025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13026     return 0;
13027   }
13028   if (!jarg2) {
13029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13030     return 0;
13031   }
13032   std::string arg2_str(jarg2);
13033   arg2 = &arg2_str;
13034   arg3 = (int)jarg3;
13035   {
13036     try {
13037       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13038     } catch (std::out_of_range& e) {
13039       {
13040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13041       };
13042     } catch (std::exception& e) {
13043       {
13044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13045       };
13046     } catch (...) {
13047       {
13048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13049       };
13050     }
13051   }
13052   jresult = (void *)result;
13053
13054   //argout typemap for const std::string&
13055
13056   return jresult;
13057 }
13058
13059
13060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13061   Dali::Property *arg1 = (Dali::Property *) 0 ;
13062
13063   arg1 = (Dali::Property *)jarg1;
13064   {
13065     try {
13066       delete arg1;
13067     } catch (std::out_of_range& e) {
13068       {
13069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13070       };
13071     } catch (std::exception& e) {
13072       {
13073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13074       };
13075     } catch (...) {
13076       {
13077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13078       };
13079     }
13080   }
13081 }
13082
13083
13084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13085   Dali::Property *arg1 = (Dali::Property *) 0 ;
13086   Dali::Handle *arg2 = 0 ;
13087
13088   arg1 = (Dali::Property *)jarg1;
13089   arg2 = (Dali::Handle *)jarg2;
13090   if (!arg2) {
13091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13092     return ;
13093   }
13094   if (arg1) (arg1)->object = *arg2;
13095 }
13096
13097
13098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13099   void * jresult ;
13100   Dali::Property *arg1 = (Dali::Property *) 0 ;
13101   Dali::Handle *result = 0 ;
13102
13103   arg1 = (Dali::Property *)jarg1;
13104   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13105   jresult = (void *)result;
13106   return jresult;
13107 }
13108
13109
13110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13111   Dali::Property *arg1 = (Dali::Property *) 0 ;
13112   Dali::Property::Index arg2 ;
13113
13114   arg1 = (Dali::Property *)jarg1;
13115   arg2 = (Dali::Property::Index)jarg2;
13116   if (arg1) (arg1)->propertyIndex = arg2;
13117 }
13118
13119
13120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13121   int jresult ;
13122   Dali::Property *arg1 = (Dali::Property *) 0 ;
13123   Dali::Property::Index result;
13124
13125   arg1 = (Dali::Property *)jarg1;
13126   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13127   jresult = result;
13128   return jresult;
13129 }
13130
13131
13132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13133   Dali::Property *arg1 = (Dali::Property *) 0 ;
13134   int arg2 ;
13135
13136   arg1 = (Dali::Property *)jarg1;
13137   arg2 = (int)jarg2;
13138   if (arg1) (arg1)->componentIndex = arg2;
13139 }
13140
13141
13142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13143   int jresult ;
13144   Dali::Property *arg1 = (Dali::Property *) 0 ;
13145   int result;
13146
13147   arg1 = (Dali::Property *)jarg1;
13148   result = (int) ((arg1)->componentIndex);
13149   jresult = result;
13150   return jresult;
13151 }
13152
13153
13154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13155   void * jresult ;
13156   Dali::Property::Array *result = 0 ;
13157
13158   {
13159     try {
13160       result = (Dali::Property::Array *)new Dali::Property::Array();
13161     } catch (std::out_of_range& e) {
13162       {
13163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13164       };
13165     } catch (std::exception& e) {
13166       {
13167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13168       };
13169     } catch (...) {
13170       {
13171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13172       };
13173     }
13174   }
13175   jresult = (void *)result;
13176   return jresult;
13177 }
13178
13179
13180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13181   void * jresult ;
13182   Dali::Property::Array *arg1 = 0 ;
13183   Dali::Property::Array *result = 0 ;
13184
13185   arg1 = (Dali::Property::Array *)jarg1;
13186   if (!arg1) {
13187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13188     return 0;
13189   }
13190   {
13191     try {
13192       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13193     } catch (std::out_of_range& e) {
13194       {
13195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13196       };
13197     } catch (std::exception& e) {
13198       {
13199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13200       };
13201     } catch (...) {
13202       {
13203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13204       };
13205     }
13206   }
13207   jresult = (void *)result;
13208   return jresult;
13209 }
13210
13211
13212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13213   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13214
13215   arg1 = (Dali::Property::Array *)jarg1;
13216   {
13217     try {
13218       delete arg1;
13219     } catch (std::out_of_range& e) {
13220       {
13221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13222       };
13223     } catch (std::exception& e) {
13224       {
13225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13226       };
13227     } catch (...) {
13228       {
13229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13230       };
13231     }
13232   }
13233 }
13234
13235
13236 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13237   unsigned long jresult ;
13238   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13239   Dali::Property::Array::SizeType result;
13240
13241   arg1 = (Dali::Property::Array *)jarg1;
13242   {
13243     try {
13244       result = ((Dali::Property::Array const *)arg1)->Size();
13245     } catch (std::out_of_range& e) {
13246       {
13247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13248       };
13249     } catch (std::exception& e) {
13250       {
13251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13252       };
13253     } catch (...) {
13254       {
13255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13256       };
13257     }
13258   }
13259   jresult = (unsigned long)result;
13260   return jresult;
13261 }
13262
13263
13264 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13265   unsigned long jresult ;
13266   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13267   Dali::Property::Array::SizeType result;
13268
13269   arg1 = (Dali::Property::Array *)jarg1;
13270   {
13271     try {
13272       result = ((Dali::Property::Array const *)arg1)->Count();
13273     } catch (std::out_of_range& e) {
13274       {
13275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13276       };
13277     } catch (std::exception& e) {
13278       {
13279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13280       };
13281     } catch (...) {
13282       {
13283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13284       };
13285     }
13286   }
13287   jresult = (unsigned long)result;
13288   return jresult;
13289 }
13290
13291
13292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13293   unsigned int jresult ;
13294   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13295   bool result;
13296
13297   arg1 = (Dali::Property::Array *)jarg1;
13298   {
13299     try {
13300       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13301     } catch (std::out_of_range& e) {
13302       {
13303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13304       };
13305     } catch (std::exception& e) {
13306       {
13307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13308       };
13309     } catch (...) {
13310       {
13311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13312       };
13313     }
13314   }
13315   jresult = result;
13316   return jresult;
13317 }
13318
13319
13320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13321   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13322
13323   arg1 = (Dali::Property::Array *)jarg1;
13324   {
13325     try {
13326       (arg1)->Clear();
13327     } catch (std::out_of_range& e) {
13328       {
13329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13330       };
13331     } catch (std::exception& e) {
13332       {
13333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13334       };
13335     } catch (...) {
13336       {
13337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13338       };
13339     }
13340   }
13341 }
13342
13343
13344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13345   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13346   Dali::Property::Array::SizeType arg2 ;
13347
13348   arg1 = (Dali::Property::Array *)jarg1;
13349   arg2 = (Dali::Property::Array::SizeType)jarg2;
13350   {
13351     try {
13352       (arg1)->Reserve(arg2);
13353     } catch (std::out_of_range& e) {
13354       {
13355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13356       };
13357     } catch (std::exception& e) {
13358       {
13359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13360       };
13361     } catch (...) {
13362       {
13363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13364       };
13365     }
13366   }
13367 }
13368
13369
13370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13371   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13372   Dali::Property::Array::SizeType arg2 ;
13373
13374   arg1 = (Dali::Property::Array *)jarg1;
13375   arg2 = (Dali::Property::Array::SizeType)jarg2;
13376   {
13377     try {
13378       (arg1)->Resize(arg2);
13379     } catch (std::out_of_range& e) {
13380       {
13381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13382       };
13383     } catch (std::exception& e) {
13384       {
13385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13386       };
13387     } catch (...) {
13388       {
13389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13390       };
13391     }
13392   }
13393 }
13394
13395
13396 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13397   unsigned long jresult ;
13398   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13399   Dali::Property::Array::SizeType result;
13400
13401   arg1 = (Dali::Property::Array *)jarg1;
13402   {
13403     try {
13404       result = (arg1)->Capacity();
13405     } catch (std::out_of_range& e) {
13406       {
13407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13408       };
13409     } catch (std::exception& e) {
13410       {
13411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13412       };
13413     } catch (...) {
13414       {
13415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13416       };
13417     }
13418   }
13419   jresult = (unsigned long)result;
13420   return jresult;
13421 }
13422
13423
13424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13425   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13426   Dali::Property::Value *arg2 = 0 ;
13427
13428   arg1 = (Dali::Property::Array *)jarg1;
13429   arg2 = (Dali::Property::Value *)jarg2;
13430   if (!arg2) {
13431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13432     return ;
13433   }
13434   {
13435     try {
13436       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13437     } catch (std::out_of_range& e) {
13438       {
13439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13440       };
13441     } catch (std::exception& e) {
13442       {
13443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13444       };
13445     } catch (...) {
13446       {
13447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13448       };
13449     }
13450   }
13451 }
13452
13453
13454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13455   void * jresult ;
13456   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13457   Dali::Property::Value *arg2 = 0 ;
13458   Dali::Property::Array *result = 0 ;
13459
13460   arg1 = (Dali::Property::Array *)jarg1;
13461   arg2 = (Dali::Property::Value *)jarg2;
13462   if (!arg2) {
13463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13464     return 0;
13465   }
13466   {
13467     try {
13468       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13469     } catch (std::out_of_range& e) {
13470       {
13471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13472       };
13473     } catch (std::exception& e) {
13474       {
13475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13476       };
13477     } catch (...) {
13478       {
13479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13480       };
13481     }
13482   }
13483   jresult = (void *)result;
13484   return jresult;
13485 }
13486
13487
13488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13489   void * jresult ;
13490   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13491   Dali::Property::Array::SizeType arg2 ;
13492   Dali::Property::Value *result = 0 ;
13493
13494   arg1 = (Dali::Property::Array *)jarg1;
13495   arg2 = (Dali::Property::Array::SizeType)jarg2;
13496   {
13497     try {
13498       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13499     } catch (std::out_of_range& e) {
13500       {
13501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13502       };
13503     } catch (std::exception& e) {
13504       {
13505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13506       };
13507     } catch (...) {
13508       {
13509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13510       };
13511     }
13512   }
13513   jresult = (void *)result;
13514   return jresult;
13515 }
13516
13517
13518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13519   void * jresult ;
13520   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13521   Dali::Property::Array::SizeType arg2 ;
13522   Dali::Property::Value *result = 0 ;
13523
13524   arg1 = (Dali::Property::Array *)jarg1;
13525   arg2 = (Dali::Property::Array::SizeType)jarg2;
13526   {
13527     try {
13528       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13529     } catch (std::out_of_range& e) {
13530       {
13531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13532       };
13533     } catch (std::exception& e) {
13534       {
13535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13536       };
13537     } catch (...) {
13538       {
13539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13540       };
13541     }
13542   }
13543   jresult = (void *)result;
13544   return jresult;
13545 }
13546
13547
13548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13549   void * jresult ;
13550   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13551   Dali::Property::Array *arg2 = 0 ;
13552   Dali::Property::Array *result = 0 ;
13553
13554   arg1 = (Dali::Property::Array *)jarg1;
13555   arg2 = (Dali::Property::Array *)jarg2;
13556   if (!arg2) {
13557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13558     return 0;
13559   }
13560   {
13561     try {
13562       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13563     } catch (std::out_of_range& e) {
13564       {
13565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13566       };
13567     } catch (std::exception& e) {
13568       {
13569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13570       };
13571     } catch (...) {
13572       {
13573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13574       };
13575     }
13576   }
13577   jresult = (void *)result;
13578   return jresult;
13579 }
13580
13581
13582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13583   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13584   enum Dali::Property::Key::Type arg2 ;
13585
13586   arg1 = (Dali::Property::Key *)jarg1;
13587   arg2 = (enum Dali::Property::Key::Type)jarg2;
13588   if (arg1) (arg1)->type = arg2;
13589 }
13590
13591
13592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13593   int jresult ;
13594   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13595   enum Dali::Property::Key::Type result;
13596
13597   arg1 = (Dali::Property::Key *)jarg1;
13598   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13599   jresult = (int)result;
13600   return jresult;
13601 }
13602
13603
13604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13605   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13606   Dali::Property::Index arg2 ;
13607
13608   arg1 = (Dali::Property::Key *)jarg1;
13609   arg2 = (Dali::Property::Index)jarg2;
13610   if (arg1) (arg1)->indexKey = arg2;
13611 }
13612
13613
13614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13615   int jresult ;
13616   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13617   Dali::Property::Index result;
13618
13619   arg1 = (Dali::Property::Key *)jarg1;
13620   result = (Dali::Property::Index) ((arg1)->indexKey);
13621   jresult = result;
13622   return jresult;
13623 }
13624
13625
13626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13627   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13628   std::string *arg2 = 0 ;
13629
13630   arg1 = (Dali::Property::Key *)jarg1;
13631   if (!jarg2) {
13632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13633     return ;
13634   }
13635   std::string arg2_str(jarg2);
13636   arg2 = &arg2_str;
13637   if (arg1) (arg1)->stringKey = *arg2;
13638
13639   //argout typemap for const std::string&
13640
13641 }
13642
13643
13644 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13645   char * jresult ;
13646   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13647   std::string *result = 0 ;
13648
13649   arg1 = (Dali::Property::Key *)jarg1;
13650   result = (std::string *) & ((arg1)->stringKey);
13651   jresult = SWIG_csharp_string_callback(result->c_str());
13652   return jresult;
13653 }
13654
13655
13656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13657   void * jresult ;
13658   std::string *arg1 = 0 ;
13659   Dali::Property::Key *result = 0 ;
13660
13661   if (!jarg1) {
13662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13663     return 0;
13664   }
13665   std::string arg1_str(jarg1);
13666   arg1 = &arg1_str;
13667   {
13668     try {
13669       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13670     } catch (std::out_of_range& e) {
13671       {
13672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13673       };
13674     } catch (std::exception& e) {
13675       {
13676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13677       };
13678     } catch (...) {
13679       {
13680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13681       };
13682     }
13683   }
13684   jresult = (void *)result;
13685
13686   //argout typemap for const std::string&
13687
13688   return jresult;
13689 }
13690
13691
13692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13693   void * jresult ;
13694   Dali::Property::Index arg1 ;
13695   Dali::Property::Key *result = 0 ;
13696
13697   arg1 = (Dali::Property::Index)jarg1;
13698   {
13699     try {
13700       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13701     } catch (std::out_of_range& e) {
13702       {
13703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13704       };
13705     } catch (std::exception& e) {
13706       {
13707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13708       };
13709     } catch (...) {
13710       {
13711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13712       };
13713     }
13714   }
13715   jresult = (void *)result;
13716   return jresult;
13717 }
13718
13719
13720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13721   unsigned int jresult ;
13722   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13723   std::string *arg2 = 0 ;
13724   bool result;
13725
13726   arg1 = (Dali::Property::Key *)jarg1;
13727   if (!jarg2) {
13728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13729     return 0;
13730   }
13731   std::string arg2_str(jarg2);
13732   arg2 = &arg2_str;
13733   {
13734     try {
13735       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13736     } catch (std::out_of_range& e) {
13737       {
13738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13739       };
13740     } catch (std::exception& e) {
13741       {
13742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13743       };
13744     } catch (...) {
13745       {
13746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13747       };
13748     }
13749   }
13750   jresult = result;
13751
13752   //argout typemap for const std::string&
13753
13754   return jresult;
13755 }
13756
13757
13758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13759   unsigned int jresult ;
13760   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13761   Dali::Property::Index arg2 ;
13762   bool result;
13763
13764   arg1 = (Dali::Property::Key *)jarg1;
13765   arg2 = (Dali::Property::Index)jarg2;
13766   {
13767     try {
13768       result = (bool)(arg1)->operator ==(arg2);
13769     } catch (std::out_of_range& e) {
13770       {
13771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13772       };
13773     } catch (std::exception& e) {
13774       {
13775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13776       };
13777     } catch (...) {
13778       {
13779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13780       };
13781     }
13782   }
13783   jresult = result;
13784   return jresult;
13785 }
13786
13787
13788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13789   unsigned int jresult ;
13790   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13791   Dali::Property::Key *arg2 = 0 ;
13792   bool result;
13793
13794   arg1 = (Dali::Property::Key *)jarg1;
13795   arg2 = (Dali::Property::Key *)jarg2;
13796   if (!arg2) {
13797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13798     return 0;
13799   }
13800   {
13801     try {
13802       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13803     } catch (std::out_of_range& e) {
13804       {
13805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13806       };
13807     } catch (std::exception& e) {
13808       {
13809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13810       };
13811     } catch (...) {
13812       {
13813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13814       };
13815     }
13816   }
13817   jresult = result;
13818   return jresult;
13819 }
13820
13821
13822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13823   unsigned int jresult ;
13824   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13825   std::string *arg2 = 0 ;
13826   bool result;
13827
13828   arg1 = (Dali::Property::Key *)jarg1;
13829   if (!jarg2) {
13830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13831     return 0;
13832   }
13833   std::string arg2_str(jarg2);
13834   arg2 = &arg2_str;
13835   {
13836     try {
13837       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13838     } catch (std::out_of_range& e) {
13839       {
13840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13841       };
13842     } catch (std::exception& e) {
13843       {
13844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13845       };
13846     } catch (...) {
13847       {
13848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13849       };
13850     }
13851   }
13852   jresult = result;
13853
13854   //argout typemap for const std::string&
13855
13856   return jresult;
13857 }
13858
13859
13860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13861   unsigned int jresult ;
13862   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13863   Dali::Property::Index arg2 ;
13864   bool result;
13865
13866   arg1 = (Dali::Property::Key *)jarg1;
13867   arg2 = (Dali::Property::Index)jarg2;
13868   {
13869     try {
13870       result = (bool)(arg1)->operator !=(arg2);
13871     } catch (std::out_of_range& e) {
13872       {
13873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13874       };
13875     } catch (std::exception& e) {
13876       {
13877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13878       };
13879     } catch (...) {
13880       {
13881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13882       };
13883     }
13884   }
13885   jresult = result;
13886   return jresult;
13887 }
13888
13889
13890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13891   unsigned int jresult ;
13892   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13893   Dali::Property::Key *arg2 = 0 ;
13894   bool result;
13895
13896   arg1 = (Dali::Property::Key *)jarg1;
13897   arg2 = (Dali::Property::Key *)jarg2;
13898   if (!arg2) {
13899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13900     return 0;
13901   }
13902   {
13903     try {
13904       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13905     } catch (std::out_of_range& e) {
13906       {
13907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13908       };
13909     } catch (std::exception& e) {
13910       {
13911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13912       };
13913     } catch (...) {
13914       {
13915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13916       };
13917     }
13918   }
13919   jresult = result;
13920   return jresult;
13921 }
13922
13923
13924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13925   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13926
13927   arg1 = (Dali::Property::Key *)jarg1;
13928   {
13929     try {
13930       delete arg1;
13931     } catch (std::out_of_range& e) {
13932       {
13933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13934       };
13935     } catch (std::exception& e) {
13936       {
13937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13938       };
13939     } catch (...) {
13940       {
13941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13942       };
13943     }
13944   }
13945 }
13946
13947
13948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13949   void * jresult ;
13950   Dali::Property::Map *result = 0 ;
13951
13952   {
13953     try {
13954       result = (Dali::Property::Map *)new Dali::Property::Map();
13955     } catch (std::out_of_range& e) {
13956       {
13957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13958       };
13959     } catch (std::exception& e) {
13960       {
13961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13962       };
13963     } catch (...) {
13964       {
13965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13966       };
13967     }
13968   }
13969   jresult = (void *)result;
13970   return jresult;
13971 }
13972
13973
13974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
13975   void * jresult ;
13976   Dali::Property::Map *arg1 = 0 ;
13977   Dali::Property::Map *result = 0 ;
13978
13979   arg1 = (Dali::Property::Map *)jarg1;
13980   if (!arg1) {
13981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13982     return 0;
13983   }
13984   {
13985     try {
13986       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
13987     } catch (std::out_of_range& e) {
13988       {
13989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13990       };
13991     } catch (std::exception& e) {
13992       {
13993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13994       };
13995     } catch (...) {
13996       {
13997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13998       };
13999     }
14000   }
14001   jresult = (void *)result;
14002   return jresult;
14003 }
14004
14005
14006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14007   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14008
14009   arg1 = (Dali::Property::Map *)jarg1;
14010   {
14011     try {
14012       delete arg1;
14013     } catch (std::out_of_range& e) {
14014       {
14015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14016       };
14017     } catch (std::exception& e) {
14018       {
14019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14020       };
14021     } catch (...) {
14022       {
14023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14024       };
14025     }
14026   }
14027 }
14028
14029
14030 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14031   unsigned long jresult ;
14032   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14033   Dali::Property::Map::SizeType result;
14034
14035   arg1 = (Dali::Property::Map *)jarg1;
14036   {
14037     try {
14038       result = ((Dali::Property::Map const *)arg1)->Count();
14039     } catch (std::out_of_range& e) {
14040       {
14041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14042       };
14043     } catch (std::exception& e) {
14044       {
14045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14046       };
14047     } catch (...) {
14048       {
14049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14050       };
14051     }
14052   }
14053   jresult = (unsigned long)result;
14054   return jresult;
14055 }
14056
14057
14058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14059   unsigned int jresult ;
14060   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14061   bool result;
14062
14063   arg1 = (Dali::Property::Map *)jarg1;
14064   {
14065     try {
14066       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14067     } catch (std::out_of_range& e) {
14068       {
14069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14070       };
14071     } catch (std::exception& e) {
14072       {
14073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14074       };
14075     } catch (...) {
14076       {
14077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14078       };
14079     }
14080   }
14081   jresult = result;
14082   return jresult;
14083 }
14084
14085
14086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14087   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14088   char *arg2 = (char *) 0 ;
14089   Dali::Property::Value *arg3 = 0 ;
14090
14091   arg1 = (Dali::Property::Map *)jarg1;
14092   arg2 = (char *)jarg2;
14093   arg3 = (Dali::Property::Value *)jarg3;
14094   if (!arg3) {
14095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14096     return ;
14097   }
14098   {
14099     try {
14100       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14101     } catch (std::out_of_range& e) {
14102       {
14103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14104       };
14105     } catch (std::exception& e) {
14106       {
14107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14108       };
14109     } catch (...) {
14110       {
14111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14112       };
14113     }
14114   }
14115 }
14116
14117
14118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14119   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14120   Dali::Property::Index arg2 ;
14121   Dali::Property::Value *arg3 = 0 ;
14122
14123   arg1 = (Dali::Property::Map *)jarg1;
14124   arg2 = (Dali::Property::Index)jarg2;
14125   arg3 = (Dali::Property::Value *)jarg3;
14126   if (!arg3) {
14127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14128     return ;
14129   }
14130   {
14131     try {
14132       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14133     } catch (std::out_of_range& e) {
14134       {
14135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14136       };
14137     } catch (std::exception& e) {
14138       {
14139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14140       };
14141     } catch (...) {
14142       {
14143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14144       };
14145     }
14146   }
14147 }
14148
14149
14150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14151   void * jresult ;
14152   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14153   char *arg2 = (char *) 0 ;
14154   Dali::Property::Value *arg3 = 0 ;
14155   Dali::Property::Map *result = 0 ;
14156
14157   arg1 = (Dali::Property::Map *)jarg1;
14158   arg2 = (char *)jarg2;
14159   arg3 = (Dali::Property::Value *)jarg3;
14160   if (!arg3) {
14161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14162     return 0;
14163   }
14164   {
14165     try {
14166       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14167     } catch (std::out_of_range& e) {
14168       {
14169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14170       };
14171     } catch (std::exception& e) {
14172       {
14173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14174       };
14175     } catch (...) {
14176       {
14177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14178       };
14179     }
14180   }
14181   jresult = (void *)result;
14182   return jresult;
14183 }
14184
14185
14186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14187   void * jresult ;
14188   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14189   Dali::Property::Index arg2 ;
14190   Dali::Property::Value *arg3 = 0 ;
14191   Dali::Property::Map *result = 0 ;
14192
14193   arg1 = (Dali::Property::Map *)jarg1;
14194   arg2 = (Dali::Property::Index)jarg2;
14195   arg3 = (Dali::Property::Value *)jarg3;
14196   if (!arg3) {
14197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14198     return 0;
14199   }
14200   {
14201     try {
14202       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14203     } catch (std::out_of_range& e) {
14204       {
14205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14206       };
14207     } catch (std::exception& e) {
14208       {
14209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14210       };
14211     } catch (...) {
14212       {
14213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14214       };
14215     }
14216   }
14217   jresult = (void *)result;
14218   return jresult;
14219 }
14220
14221
14222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14223   void * jresult ;
14224   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14225   Dali::Property::Map::SizeType arg2 ;
14226   Dali::Property::Value *result = 0 ;
14227
14228   arg1 = (Dali::Property::Map *)jarg1;
14229   arg2 = (Dali::Property::Map::SizeType)jarg2;
14230   {
14231     try {
14232       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14233     } catch (std::out_of_range& e) {
14234       {
14235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14236       };
14237     } catch (std::exception& e) {
14238       {
14239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14240       };
14241     } catch (...) {
14242       {
14243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14244       };
14245     }
14246   }
14247   jresult = (void *)result;
14248   return jresult;
14249 }
14250
14251
14252 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14253   char * jresult ;
14254   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14255   Dali::Property::Map::SizeType arg2 ;
14256   std::string *result = 0 ;
14257
14258   arg1 = (Dali::Property::Map *)jarg1;
14259   arg2 = (Dali::Property::Map::SizeType)jarg2;
14260   {
14261     try {
14262       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14263     } catch (std::out_of_range& e) {
14264       {
14265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14266       };
14267     } catch (std::exception& e) {
14268       {
14269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14270       };
14271     } catch (...) {
14272       {
14273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14274       };
14275     }
14276   }
14277   jresult = SWIG_csharp_string_callback(result->c_str());
14278   return jresult;
14279 }
14280
14281
14282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14283   void * jresult ;
14284   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14285   Dali::Property::Map::SizeType arg2 ;
14286   SwigValueWrapper< Dali::Property::Key > result;
14287
14288   arg1 = (Dali::Property::Map *)jarg1;
14289   arg2 = (Dali::Property::Map::SizeType)jarg2;
14290   {
14291     try {
14292       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14293     } catch (std::out_of_range& e) {
14294       {
14295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14296       };
14297     } catch (std::exception& e) {
14298       {
14299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14300       };
14301     } catch (...) {
14302       {
14303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14304       };
14305     }
14306   }
14307   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14308   return jresult;
14309 }
14310
14311
14312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14313   void * jresult ;
14314   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14315   Dali::Property::Map::SizeType arg2 ;
14316   StringValuePair *result = 0 ;
14317
14318   arg1 = (Dali::Property::Map *)jarg1;
14319   arg2 = (Dali::Property::Map::SizeType)jarg2;
14320   {
14321     try {
14322       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14323     } catch (std::out_of_range& e) {
14324       {
14325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14326       };
14327     } catch (std::exception& e) {
14328       {
14329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14330       };
14331     } catch (...) {
14332       {
14333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14334       };
14335     }
14336   }
14337   jresult = (void *)result;
14338   return jresult;
14339 }
14340
14341
14342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14343   void * jresult ;
14344   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14345   char *arg2 = (char *) 0 ;
14346   Dali::Property::Value *result = 0 ;
14347
14348   arg1 = (Dali::Property::Map *)jarg1;
14349   arg2 = (char *)jarg2;
14350   {
14351     try {
14352       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14353     } catch (std::out_of_range& e) {
14354       {
14355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14356       };
14357     } catch (std::exception& e) {
14358       {
14359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14360       };
14361     } catch (...) {
14362       {
14363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14364       };
14365     }
14366   }
14367   jresult = (void *)result;
14368   return jresult;
14369 }
14370
14371
14372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14373   void * jresult ;
14374   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14375   Dali::Property::Index arg2 ;
14376   Dali::Property::Value *result = 0 ;
14377
14378   arg1 = (Dali::Property::Map *)jarg1;
14379   arg2 = (Dali::Property::Index)jarg2;
14380   {
14381     try {
14382       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14383     } catch (std::out_of_range& e) {
14384       {
14385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14386       };
14387     } catch (std::exception& e) {
14388       {
14389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14390       };
14391     } catch (...) {
14392       {
14393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14394       };
14395     }
14396   }
14397   jresult = (void *)result;
14398   return jresult;
14399 }
14400
14401
14402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14403   void * jresult ;
14404   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14405   Dali::Property::Index arg2 ;
14406   std::string *arg3 = 0 ;
14407   Dali::Property::Value *result = 0 ;
14408
14409   arg1 = (Dali::Property::Map *)jarg1;
14410   arg2 = (Dali::Property::Index)jarg2;
14411   if (!jarg3) {
14412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14413     return 0;
14414   }
14415   std::string arg3_str(jarg3);
14416   arg3 = &arg3_str;
14417   {
14418     try {
14419       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14420     } catch (std::out_of_range& e) {
14421       {
14422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14423       };
14424     } catch (std::exception& e) {
14425       {
14426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14427       };
14428     } catch (...) {
14429       {
14430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14431       };
14432     }
14433   }
14434   jresult = (void *)result;
14435
14436   //argout typemap for const std::string&
14437
14438   return jresult;
14439 }
14440
14441
14442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14443   void * jresult ;
14444   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14445   std::string *arg2 = 0 ;
14446   Dali::Property::Type arg3 ;
14447   Dali::Property::Value *result = 0 ;
14448
14449   arg1 = (Dali::Property::Map *)jarg1;
14450   if (!jarg2) {
14451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14452     return 0;
14453   }
14454   std::string arg2_str(jarg2);
14455   arg2 = &arg2_str;
14456   arg3 = (Dali::Property::Type)jarg3;
14457   {
14458     try {
14459       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14460     } catch (std::out_of_range& e) {
14461       {
14462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14463       };
14464     } catch (std::exception& e) {
14465       {
14466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14467       };
14468     } catch (...) {
14469       {
14470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14471       };
14472     }
14473   }
14474   jresult = (void *)result;
14475
14476   //argout typemap for const std::string&
14477
14478   return jresult;
14479 }
14480
14481
14482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14483   void * jresult ;
14484   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14485   Dali::Property::Index arg2 ;
14486   Dali::Property::Type arg3 ;
14487   Dali::Property::Value *result = 0 ;
14488
14489   arg1 = (Dali::Property::Map *)jarg1;
14490   arg2 = (Dali::Property::Index)jarg2;
14491   arg3 = (Dali::Property::Type)jarg3;
14492   {
14493     try {
14494       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14495     } catch (std::out_of_range& e) {
14496       {
14497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (std::exception& e) {
14500       {
14501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14502       };
14503     } catch (...) {
14504       {
14505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14506       };
14507     }
14508   }
14509   jresult = (void *)result;
14510   return jresult;
14511 }
14512
14513
14514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14515   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14516
14517   arg1 = (Dali::Property::Map *)jarg1;
14518   {
14519     try {
14520       (arg1)->Clear();
14521     } catch (std::out_of_range& e) {
14522       {
14523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14524       };
14525     } catch (std::exception& e) {
14526       {
14527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14528       };
14529     } catch (...) {
14530       {
14531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14532       };
14533     }
14534   }
14535 }
14536
14537
14538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14539   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14540   Dali::Property::Map *arg2 = 0 ;
14541
14542   arg1 = (Dali::Property::Map *)jarg1;
14543   arg2 = (Dali::Property::Map *)jarg2;
14544   if (!arg2) {
14545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14546     return ;
14547   }
14548   {
14549     try {
14550       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14551     } catch (std::out_of_range& e) {
14552       {
14553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14554       };
14555     } catch (std::exception& e) {
14556       {
14557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14558       };
14559     } catch (...) {
14560       {
14561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14562       };
14563     }
14564   }
14565 }
14566
14567
14568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14569   void * jresult ;
14570   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14571   std::string *arg2 = 0 ;
14572   Dali::Property::Value *result = 0 ;
14573
14574   arg1 = (Dali::Property::Map *)jarg1;
14575   if (!jarg2) {
14576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14577     return 0;
14578   }
14579   std::string arg2_str(jarg2);
14580   arg2 = &arg2_str;
14581   {
14582     try {
14583       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14584     } catch (std::out_of_range& e) {
14585       {
14586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14587       };
14588     } catch (std::exception& e) {
14589       {
14590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14591       };
14592     } catch (...) {
14593       {
14594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14595       };
14596     }
14597   }
14598   jresult = (void *)result;
14599
14600   //argout typemap for const std::string&
14601
14602   return jresult;
14603 }
14604
14605
14606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14607   void * jresult ;
14608   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14609   Dali::Property::Index arg2 ;
14610   Dali::Property::Value *result = 0 ;
14611
14612   arg1 = (Dali::Property::Map *)jarg1;
14613   arg2 = (Dali::Property::Index)jarg2;
14614   {
14615     try {
14616       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14617     } catch (std::out_of_range& e) {
14618       {
14619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14620       };
14621     } catch (std::exception& e) {
14622       {
14623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14624       };
14625     } catch (...) {
14626       {
14627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14628       };
14629     }
14630   }
14631   jresult = (void *)result;
14632   return jresult;
14633 }
14634
14635
14636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14637   void * jresult ;
14638   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14639   Dali::Property::Map *arg2 = 0 ;
14640   Dali::Property::Map *result = 0 ;
14641
14642   arg1 = (Dali::Property::Map *)jarg1;
14643   arg2 = (Dali::Property::Map *)jarg2;
14644   if (!arg2) {
14645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14646     return 0;
14647   }
14648   {
14649     try {
14650       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14651     } catch (std::out_of_range& e) {
14652       {
14653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14654       };
14655     } catch (std::exception& e) {
14656       {
14657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14658       };
14659     } catch (...) {
14660       {
14661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14662       };
14663     }
14664   }
14665   jresult = (void *)result;
14666   return jresult;
14667 }
14668
14669
14670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14671   void * jresult ;
14672   Dali::Property::Value *result = 0 ;
14673
14674   {
14675     try {
14676       result = (Dali::Property::Value *)new Dali::Property::Value();
14677     } catch (std::out_of_range& e) {
14678       {
14679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14680       };
14681     } catch (std::exception& e) {
14682       {
14683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14684       };
14685     } catch (...) {
14686       {
14687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14688       };
14689     }
14690   }
14691   jresult = (void *)result;
14692   return jresult;
14693 }
14694
14695
14696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14697   void * jresult ;
14698   bool arg1 ;
14699   Dali::Property::Value *result = 0 ;
14700
14701   arg1 = jarg1 ? true : false;
14702   {
14703     try {
14704       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14705     } catch (std::out_of_range& e) {
14706       {
14707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14708       };
14709     } catch (std::exception& e) {
14710       {
14711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14712       };
14713     } catch (...) {
14714       {
14715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14716       };
14717     }
14718   }
14719   jresult = (void *)result;
14720   return jresult;
14721 }
14722
14723
14724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14725   void * jresult ;
14726   int arg1 ;
14727   Dali::Property::Value *result = 0 ;
14728
14729   arg1 = (int)jarg1;
14730   {
14731     try {
14732       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14733     } catch (std::out_of_range& e) {
14734       {
14735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14736       };
14737     } catch (std::exception& e) {
14738       {
14739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14740       };
14741     } catch (...) {
14742       {
14743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14744       };
14745     }
14746   }
14747   jresult = (void *)result;
14748   return jresult;
14749 }
14750
14751
14752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14753   void * jresult ;
14754   float arg1 ;
14755   Dali::Property::Value *result = 0 ;
14756
14757   arg1 = (float)jarg1;
14758   {
14759     try {
14760       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14761     } catch (std::out_of_range& e) {
14762       {
14763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14764       };
14765     } catch (std::exception& e) {
14766       {
14767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14768       };
14769     } catch (...) {
14770       {
14771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14772       };
14773     }
14774   }
14775   jresult = (void *)result;
14776   return jresult;
14777 }
14778
14779
14780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14781   void * jresult ;
14782   Dali::Vector2 *arg1 = 0 ;
14783   Dali::Property::Value *result = 0 ;
14784
14785   arg1 = (Dali::Vector2 *)jarg1;
14786   if (!arg1) {
14787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14788     return 0;
14789   }
14790   {
14791     try {
14792       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14793     } catch (std::out_of_range& e) {
14794       {
14795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14796       };
14797     } catch (std::exception& e) {
14798       {
14799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14800       };
14801     } catch (...) {
14802       {
14803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14804       };
14805     }
14806   }
14807   jresult = (void *)result;
14808   return jresult;
14809 }
14810
14811
14812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14813   void * jresult ;
14814   Dali::Vector3 *arg1 = 0 ;
14815   Dali::Property::Value *result = 0 ;
14816
14817   arg1 = (Dali::Vector3 *)jarg1;
14818   if (!arg1) {
14819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14820     return 0;
14821   }
14822   {
14823     try {
14824       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14825     } catch (std::out_of_range& e) {
14826       {
14827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14828       };
14829     } catch (std::exception& e) {
14830       {
14831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14832       };
14833     } catch (...) {
14834       {
14835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14836       };
14837     }
14838   }
14839   jresult = (void *)result;
14840   return jresult;
14841 }
14842
14843
14844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14845   void * jresult ;
14846   Dali::Vector4 *arg1 = 0 ;
14847   Dali::Property::Value *result = 0 ;
14848
14849   arg1 = (Dali::Vector4 *)jarg1;
14850   if (!arg1) {
14851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14852     return 0;
14853   }
14854   {
14855     try {
14856       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14857     } catch (std::out_of_range& e) {
14858       {
14859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14860       };
14861     } catch (std::exception& e) {
14862       {
14863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14864       };
14865     } catch (...) {
14866       {
14867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14868       };
14869     }
14870   }
14871   jresult = (void *)result;
14872   return jresult;
14873 }
14874
14875
14876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14877   void * jresult ;
14878   Dali::Matrix3 *arg1 = 0 ;
14879   Dali::Property::Value *result = 0 ;
14880
14881   arg1 = (Dali::Matrix3 *)jarg1;
14882   if (!arg1) {
14883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14884     return 0;
14885   }
14886   {
14887     try {
14888       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14889     } catch (std::out_of_range& e) {
14890       {
14891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14892       };
14893     } catch (std::exception& e) {
14894       {
14895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14896       };
14897     } catch (...) {
14898       {
14899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14900       };
14901     }
14902   }
14903   jresult = (void *)result;
14904   return jresult;
14905 }
14906
14907
14908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14909   void * jresult ;
14910   Dali::Matrix *arg1 = 0 ;
14911   Dali::Property::Value *result = 0 ;
14912
14913   arg1 = (Dali::Matrix *)jarg1;
14914   if (!arg1) {
14915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14916     return 0;
14917   }
14918   {
14919     try {
14920       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14921     } catch (std::out_of_range& e) {
14922       {
14923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14924       };
14925     } catch (std::exception& e) {
14926       {
14927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14928       };
14929     } catch (...) {
14930       {
14931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14932       };
14933     }
14934   }
14935   jresult = (void *)result;
14936   return jresult;
14937 }
14938
14939
14940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14941   void * jresult ;
14942   Dali::Rect< int > *arg1 = 0 ;
14943   Dali::Property::Value *result = 0 ;
14944
14945   arg1 = (Dali::Rect< int > *)jarg1;
14946   if (!arg1) {
14947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14948     return 0;
14949   }
14950   {
14951     try {
14952       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14953     } catch (std::out_of_range& e) {
14954       {
14955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14956       };
14957     } catch (std::exception& e) {
14958       {
14959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14960       };
14961     } catch (...) {
14962       {
14963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14964       };
14965     }
14966   }
14967   jresult = (void *)result;
14968   return jresult;
14969 }
14970
14971
14972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
14973   void * jresult ;
14974   Dali::AngleAxis *arg1 = 0 ;
14975   Dali::Property::Value *result = 0 ;
14976
14977   arg1 = (Dali::AngleAxis *)jarg1;
14978   if (!arg1) {
14979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14980     return 0;
14981   }
14982   {
14983     try {
14984       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
14985     } catch (std::out_of_range& e) {
14986       {
14987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14988       };
14989     } catch (std::exception& e) {
14990       {
14991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14992       };
14993     } catch (...) {
14994       {
14995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14996       };
14997     }
14998   }
14999   jresult = (void *)result;
15000   return jresult;
15001 }
15002
15003
15004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15005   void * jresult ;
15006   Dali::Quaternion *arg1 = 0 ;
15007   Dali::Property::Value *result = 0 ;
15008
15009   arg1 = (Dali::Quaternion *)jarg1;
15010   if (!arg1) {
15011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15012     return 0;
15013   }
15014   {
15015     try {
15016       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15017     } catch (std::out_of_range& e) {
15018       {
15019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15020       };
15021     } catch (std::exception& e) {
15022       {
15023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15024       };
15025     } catch (...) {
15026       {
15027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15028       };
15029     }
15030   }
15031   jresult = (void *)result;
15032   return jresult;
15033 }
15034
15035
15036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15037   void * jresult ;
15038   std::string *arg1 = 0 ;
15039   Dali::Property::Value *result = 0 ;
15040
15041   if (!jarg1) {
15042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15043     return 0;
15044   }
15045   std::string arg1_str(jarg1);
15046   arg1 = &arg1_str;
15047   {
15048     try {
15049       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15050     } catch (std::out_of_range& e) {
15051       {
15052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15053       };
15054     } catch (std::exception& e) {
15055       {
15056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15057       };
15058     } catch (...) {
15059       {
15060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15061       };
15062     }
15063   }
15064   jresult = (void *)result;
15065
15066   //argout typemap for const std::string&
15067
15068   return jresult;
15069 }
15070
15071
15072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15073   void * jresult ;
15074   Dali::Property::Array *arg1 = 0 ;
15075   Dali::Property::Value *result = 0 ;
15076
15077   arg1 = (Dali::Property::Array *)jarg1;
15078   if (!arg1) {
15079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15080     return 0;
15081   }
15082   {
15083     try {
15084       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15085     } catch (std::out_of_range& e) {
15086       {
15087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15088       };
15089     } catch (std::exception& e) {
15090       {
15091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15092       };
15093     } catch (...) {
15094       {
15095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15096       };
15097     }
15098   }
15099   jresult = (void *)result;
15100   return jresult;
15101 }
15102
15103
15104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15105   void * jresult ;
15106   Dali::Property::Map *arg1 = 0 ;
15107   Dali::Property::Value *result = 0 ;
15108
15109   arg1 = (Dali::Property::Map *)jarg1;
15110   if (!arg1) {
15111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15112     return 0;
15113   }
15114   {
15115     try {
15116       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15117     } catch (std::out_of_range& e) {
15118       {
15119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15120       };
15121     } catch (std::exception& e) {
15122       {
15123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15124       };
15125     } catch (...) {
15126       {
15127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15128       };
15129     }
15130   }
15131   jresult = (void *)result;
15132   return jresult;
15133 }
15134
15135
15136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15137   void * jresult ;
15138   Dali::Property::Type arg1 ;
15139   Dali::Property::Value *result = 0 ;
15140
15141   arg1 = (Dali::Property::Type)jarg1;
15142   {
15143     try {
15144       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15145     } catch (std::out_of_range& e) {
15146       {
15147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15148       };
15149     } catch (std::exception& e) {
15150       {
15151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15152       };
15153     } catch (...) {
15154       {
15155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15156       };
15157     }
15158   }
15159   jresult = (void *)result;
15160   return jresult;
15161 }
15162
15163
15164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15165   void * jresult ;
15166   Dali::Property::Value *arg1 = 0 ;
15167   Dali::Property::Value *result = 0 ;
15168
15169   arg1 = (Dali::Property::Value *)jarg1;
15170   if (!arg1) {
15171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15172     return 0;
15173   }
15174   {
15175     try {
15176       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15177     } catch (std::out_of_range& e) {
15178       {
15179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15180       };
15181     } catch (std::exception& e) {
15182       {
15183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15184       };
15185     } catch (...) {
15186       {
15187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15188       };
15189     }
15190   }
15191   jresult = (void *)result;
15192   return jresult;
15193 }
15194
15195
15196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15197   void * jresult ;
15198   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15199   Dali::Property::Value *arg2 = 0 ;
15200   Dali::Property::Value *result = 0 ;
15201
15202   arg1 = (Dali::Property::Value *)jarg1;
15203   arg2 = (Dali::Property::Value *)jarg2;
15204   if (!arg2) {
15205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15206     return 0;
15207   }
15208   {
15209     try {
15210       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15211     } catch (std::out_of_range& e) {
15212       {
15213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15214       };
15215     } catch (std::exception& e) {
15216       {
15217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15218       };
15219     } catch (...) {
15220       {
15221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15222       };
15223     }
15224   }
15225   jresult = (void *)result;
15226   return jresult;
15227 }
15228
15229
15230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15231   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15232
15233   arg1 = (Dali::Property::Value *)jarg1;
15234   {
15235     try {
15236       delete arg1;
15237     } catch (std::out_of_range& e) {
15238       {
15239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15240       };
15241     } catch (std::exception& e) {
15242       {
15243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15244       };
15245     } catch (...) {
15246       {
15247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15248       };
15249     }
15250   }
15251 }
15252
15253
15254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15255   int jresult ;
15256   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15257   Dali::Property::Type result;
15258
15259   arg1 = (Dali::Property::Value *)jarg1;
15260   {
15261     try {
15262       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15263     } catch (std::out_of_range& e) {
15264       {
15265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15266       };
15267     } catch (std::exception& e) {
15268       {
15269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15270       };
15271     } catch (...) {
15272       {
15273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15274       };
15275     }
15276   }
15277   jresult = (int)result;
15278   return jresult;
15279 }
15280
15281
15282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15283   unsigned int jresult ;
15284   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15285   bool *arg2 = 0 ;
15286   bool result;
15287
15288   arg1 = (Dali::Property::Value *)jarg1;
15289   arg2 = (bool *)jarg2;
15290   {
15291     try {
15292       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15293     } catch (std::out_of_range& e) {
15294       {
15295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15296       };
15297     } catch (std::exception& e) {
15298       {
15299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15300       };
15301     } catch (...) {
15302       {
15303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15304       };
15305     }
15306   }
15307   jresult = result;
15308   return jresult;
15309 }
15310
15311
15312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15313   unsigned int jresult ;
15314   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15315   float *arg2 = 0 ;
15316   bool result;
15317
15318   arg1 = (Dali::Property::Value *)jarg1;
15319   arg2 = (float *)jarg2;
15320   {
15321     try {
15322       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15323     } catch (std::out_of_range& e) {
15324       {
15325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15326       };
15327     } catch (std::exception& e) {
15328       {
15329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15330       };
15331     } catch (...) {
15332       {
15333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15334       };
15335     }
15336   }
15337   jresult = result;
15338   return jresult;
15339 }
15340
15341
15342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15343   unsigned int jresult ;
15344   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15345   int *arg2 = 0 ;
15346   bool result;
15347
15348   arg1 = (Dali::Property::Value *)jarg1;
15349   arg2 = (int *)jarg2;
15350   {
15351     try {
15352       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15353     } catch (std::out_of_range& e) {
15354       {
15355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15356       };
15357     } catch (std::exception& e) {
15358       {
15359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15360       };
15361     } catch (...) {
15362       {
15363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15364       };
15365     }
15366   }
15367   jresult = result;
15368   return jresult;
15369 }
15370
15371
15372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15373   unsigned int jresult ;
15374   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15375   Dali::Rect< int > *arg2 = 0 ;
15376   bool result;
15377
15378   arg1 = (Dali::Property::Value *)jarg1;
15379   arg2 = (Dali::Rect< int > *)jarg2;
15380   if (!arg2) {
15381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15382     return 0;
15383   }
15384   {
15385     try {
15386       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15387     } catch (std::out_of_range& e) {
15388       {
15389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15390       };
15391     } catch (std::exception& e) {
15392       {
15393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15394       };
15395     } catch (...) {
15396       {
15397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15398       };
15399     }
15400   }
15401   jresult = result;
15402   return jresult;
15403 }
15404
15405
15406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15407   unsigned int jresult ;
15408   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15409   Dali::Vector2 *arg2 = 0 ;
15410   bool result;
15411
15412   arg1 = (Dali::Property::Value *)jarg1;
15413   arg2 = (Dali::Vector2 *)jarg2;
15414   if (!arg2) {
15415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15416     return 0;
15417   }
15418   {
15419     try {
15420       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15421     } catch (std::out_of_range& e) {
15422       {
15423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15424       };
15425     } catch (std::exception& e) {
15426       {
15427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15428       };
15429     } catch (...) {
15430       {
15431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15432       };
15433     }
15434   }
15435   jresult = result;
15436   return jresult;
15437 }
15438
15439
15440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15441   unsigned int jresult ;
15442   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15443   Dali::Vector3 *arg2 = 0 ;
15444   bool result;
15445
15446   arg1 = (Dali::Property::Value *)jarg1;
15447   arg2 = (Dali::Vector3 *)jarg2;
15448   if (!arg2) {
15449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15450     return 0;
15451   }
15452   {
15453     try {
15454       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15455     } catch (std::out_of_range& e) {
15456       {
15457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15458       };
15459     } catch (std::exception& e) {
15460       {
15461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15462       };
15463     } catch (...) {
15464       {
15465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15466       };
15467     }
15468   }
15469   jresult = result;
15470   return jresult;
15471 }
15472
15473
15474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15475   unsigned int jresult ;
15476   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15477   Dali::Vector4 *arg2 = 0 ;
15478   bool result;
15479
15480   arg1 = (Dali::Property::Value *)jarg1;
15481   arg2 = (Dali::Vector4 *)jarg2;
15482   if (!arg2) {
15483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15484     return 0;
15485   }
15486   {
15487     try {
15488       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15489     } catch (std::out_of_range& e) {
15490       {
15491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15492       };
15493     } catch (std::exception& e) {
15494       {
15495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15496       };
15497     } catch (...) {
15498       {
15499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15500       };
15501     }
15502   }
15503   jresult = result;
15504   return jresult;
15505 }
15506
15507
15508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15509   unsigned int jresult ;
15510   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15511   Dali::Matrix3 *arg2 = 0 ;
15512   bool result;
15513
15514   arg1 = (Dali::Property::Value *)jarg1;
15515   arg2 = (Dali::Matrix3 *)jarg2;
15516   if (!arg2) {
15517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15518     return 0;
15519   }
15520   {
15521     try {
15522       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15523     } catch (std::out_of_range& e) {
15524       {
15525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15526       };
15527     } catch (std::exception& e) {
15528       {
15529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15530       };
15531     } catch (...) {
15532       {
15533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15534       };
15535     }
15536   }
15537   jresult = result;
15538   return jresult;
15539 }
15540
15541
15542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15543   unsigned int jresult ;
15544   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15545   Dali::Matrix *arg2 = 0 ;
15546   bool result;
15547
15548   arg1 = (Dali::Property::Value *)jarg1;
15549   arg2 = (Dali::Matrix *)jarg2;
15550   if (!arg2) {
15551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15552     return 0;
15553   }
15554   {
15555     try {
15556       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15557     } catch (std::out_of_range& e) {
15558       {
15559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15560       };
15561     } catch (std::exception& e) {
15562       {
15563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15564       };
15565     } catch (...) {
15566       {
15567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15568       };
15569     }
15570   }
15571   jresult = result;
15572   return jresult;
15573 }
15574
15575
15576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15577   unsigned int jresult ;
15578   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15579   Dali::AngleAxis *arg2 = 0 ;
15580   bool result;
15581
15582   arg1 = (Dali::Property::Value *)jarg1;
15583   arg2 = (Dali::AngleAxis *)jarg2;
15584   if (!arg2) {
15585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15586     return 0;
15587   }
15588   {
15589     try {
15590       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15591     } catch (std::out_of_range& e) {
15592       {
15593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15594       };
15595     } catch (std::exception& e) {
15596       {
15597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15598       };
15599     } catch (...) {
15600       {
15601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15602       };
15603     }
15604   }
15605   jresult = result;
15606   return jresult;
15607 }
15608
15609
15610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15611   unsigned int jresult ;
15612   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15613   Dali::Quaternion *arg2 = 0 ;
15614   bool result;
15615
15616   arg1 = (Dali::Property::Value *)jarg1;
15617   arg2 = (Dali::Quaternion *)jarg2;
15618   if (!arg2) {
15619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15620     return 0;
15621   }
15622   {
15623     try {
15624       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15625     } catch (std::out_of_range& e) {
15626       {
15627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15628       };
15629     } catch (std::exception& e) {
15630       {
15631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15632       };
15633     } catch (...) {
15634       {
15635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15636       };
15637     }
15638   }
15639   jresult = result;
15640   return jresult;
15641 }
15642
15643
15644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15645   unsigned int jresult ;
15646   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15647   std::string *arg2 = 0 ;
15648   bool result;
15649
15650   arg1 = (Dali::Property::Value *)jarg1;
15651
15652   //typemap in
15653   std::string temp;
15654   arg2 = &temp;
15655
15656   {
15657     try {
15658       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15659     } catch (std::out_of_range& e) {
15660       {
15661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15662       };
15663     } catch (std::exception& e) {
15664       {
15665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15666       };
15667     } catch (...) {
15668       {
15669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15670       };
15671     }
15672   }
15673   jresult = result;
15674
15675   //Typemap argout in c++ file.
15676   //This will convert c++ string to c# string
15677   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15678
15679   return jresult;
15680 }
15681
15682
15683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15684   unsigned int jresult ;
15685   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15686   Dali::Property::Array *arg2 = 0 ;
15687   bool result;
15688
15689   arg1 = (Dali::Property::Value *)jarg1;
15690   arg2 = (Dali::Property::Array *)jarg2;
15691   if (!arg2) {
15692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15693     return 0;
15694   }
15695   {
15696     try {
15697       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15698     } catch (std::out_of_range& e) {
15699       {
15700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15701       };
15702     } catch (std::exception& e) {
15703       {
15704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15705       };
15706     } catch (...) {
15707       {
15708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15709       };
15710     }
15711   }
15712   jresult = result;
15713   return jresult;
15714 }
15715
15716
15717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15718   unsigned int jresult ;
15719   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15720   Dali::Property::Map *arg2 = 0 ;
15721   bool result;
15722
15723   arg1 = (Dali::Property::Value *)jarg1;
15724   arg2 = (Dali::Property::Map *)jarg2;
15725   if (!arg2) {
15726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15727     return 0;
15728   }
15729   {
15730     try {
15731       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15732     } catch (std::out_of_range& e) {
15733       {
15734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15735       };
15736     } catch (std::exception& e) {
15737       {
15738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15739       };
15740     } catch (...) {
15741       {
15742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15743       };
15744     }
15745   }
15746   jresult = result;
15747   return jresult;
15748 }
15749
15750
15751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15752   void * jresult ;
15753   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15754   Dali::Property::Array *result = 0 ;
15755
15756   arg1 = (Dali::Property::Value *)jarg1;
15757   {
15758     try {
15759       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15760     } catch (std::out_of_range& e) {
15761       {
15762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15763       };
15764     } catch (std::exception& e) {
15765       {
15766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15767       };
15768     } catch (...) {
15769       {
15770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15771       };
15772     }
15773   }
15774   jresult = (void *)result;
15775   return jresult;
15776 }
15777
15778
15779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15780   void * jresult ;
15781   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15782   Dali::Property::Map *result = 0 ;
15783
15784   arg1 = (Dali::Property::Value *)jarg1;
15785   {
15786     try {
15787       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15788     } catch (std::out_of_range& e) {
15789       {
15790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15791       };
15792     } catch (std::exception& e) {
15793       {
15794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15795       };
15796     } catch (...) {
15797       {
15798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15799       };
15800     }
15801   }
15802   jresult = (void *)result;
15803   return jresult;
15804 }
15805
15806
15807 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15808   char * jresult ;
15809   Dali::Property::Type arg1 ;
15810   char *result = 0 ;
15811
15812   arg1 = (Dali::Property::Type)jarg1;
15813   {
15814     try {
15815       result = (char *)Dali::PropertyTypes::GetName(arg1);
15816     } catch (std::out_of_range& e) {
15817       {
15818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15819       };
15820     } catch (std::exception& e) {
15821       {
15822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15823       };
15824     } catch (...) {
15825       {
15826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15827       };
15828     }
15829   }
15830   jresult = SWIG_csharp_string_callback((const char *)result);
15831   return jresult;
15832 }
15833
15834
15835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15836   unsigned int jresult ;
15837   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15838   std::string *arg2 = 0 ;
15839   Dali::Property::Map *arg3 = 0 ;
15840   bool result;
15841
15842   arg1 = (Dali::BaseObject *)jarg1;
15843   if (!jarg2) {
15844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15845     return 0;
15846   }
15847   std::string arg2_str(jarg2);
15848   arg2 = &arg2_str;
15849   arg3 = (Dali::Property::Map *)jarg3;
15850   if (!arg3) {
15851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15852     return 0;
15853   }
15854   {
15855     try {
15856       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15857     } catch (std::out_of_range& e) {
15858       {
15859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15860       };
15861     } catch (std::exception& e) {
15862       {
15863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15864       };
15865     } catch (...) {
15866       {
15867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15868       };
15869     }
15870   }
15871   jresult = result;
15872
15873   //argout typemap for const std::string&
15874
15875   return jresult;
15876 }
15877
15878
15879 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15880   char * jresult ;
15881   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15882   std::string *result = 0 ;
15883
15884   arg1 = (Dali::BaseObject *)jarg1;
15885   {
15886     try {
15887       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15888     } catch (std::out_of_range& e) {
15889       {
15890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15891       };
15892     } catch (std::exception& e) {
15893       {
15894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15895       };
15896     } catch (...) {
15897       {
15898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15899       };
15900     }
15901   }
15902   jresult = SWIG_csharp_string_callback(result->c_str());
15903   return jresult;
15904 }
15905
15906
15907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15908   unsigned int jresult ;
15909   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15910   Dali::TypeInfo *arg2 = 0 ;
15911   bool result;
15912
15913   arg1 = (Dali::BaseObject *)jarg1;
15914   arg2 = (Dali::TypeInfo *)jarg2;
15915   if (!arg2) {
15916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15917     return 0;
15918   }
15919   {
15920     try {
15921       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15922     } catch (std::out_of_range& e) {
15923       {
15924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15925       };
15926     } catch (std::exception& e) {
15927       {
15928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15929       };
15930     } catch (...) {
15931       {
15932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15933       };
15934     }
15935   }
15936   jresult = result;
15937   return jresult;
15938 }
15939
15940
15941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15942   unsigned int jresult ;
15943   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15944   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15945   std::string *arg3 = 0 ;
15946   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15947   bool result;
15948
15949   arg1 = (Dali::BaseObject *)jarg1;
15950   arg2 = (ConnectionTrackerInterface *)jarg2;
15951   if (!jarg3) {
15952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15953     return 0;
15954   }
15955   std::string arg3_str(jarg3);
15956   arg3 = &arg3_str;
15957   arg4 = (FunctorDelegate *)jarg4;
15958   {
15959     try {
15960       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15961     } catch (std::out_of_range& e) {
15962       {
15963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15964       };
15965     } catch (std::exception& e) {
15966       {
15967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15968       };
15969     } catch (...) {
15970       {
15971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15972       };
15973     }
15974   }
15975   jresult = result;
15976
15977   //argout typemap for const std::string&
15978
15979   return jresult;
15980 }
15981
15982
15983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
15984   void * jresult ;
15985   Dali::BaseHandle *arg1 = 0 ;
15986   Dali::BaseObject *result = 0 ;
15987
15988   arg1 = (Dali::BaseHandle *)jarg1;
15989   if (!arg1) {
15990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
15991     return 0;
15992   }
15993   {
15994     try {
15995       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
15996     } catch (std::out_of_range& e) {
15997       {
15998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15999       };
16000     } catch (std::exception& e) {
16001       {
16002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16003       };
16004     } catch (...) {
16005       {
16006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16007       };
16008     }
16009   }
16010   jresult = (void *)result;
16011   return jresult;
16012 }
16013
16014
16015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16016   void * jresult ;
16017   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16018   Dali::BaseHandle *result = 0 ;
16019
16020   arg1 = (Dali::BaseObject *)jarg1;
16021   {
16022     try {
16023       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16024     } catch (std::out_of_range& e) {
16025       {
16026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16027       };
16028     } catch (std::exception& e) {
16029       {
16030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16031       };
16032     } catch (...) {
16033       {
16034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16035       };
16036     }
16037   }
16038   jresult = (void *)result;
16039   return jresult;
16040 }
16041
16042
16043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16044   void * jresult ;
16045   Dali::BaseHandle *result = 0 ;
16046
16047   {
16048     try {
16049       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16050     } catch (std::out_of_range& e) {
16051       {
16052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16053       };
16054     } catch (std::exception& e) {
16055       {
16056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16057       };
16058     } catch (...) {
16059       {
16060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16061       };
16062     }
16063   }
16064   jresult = (void *)result;
16065   return jresult;
16066 }
16067
16068
16069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16070   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16071
16072   arg1 = (Dali::BaseHandle *)jarg1;
16073   {
16074     try {
16075       delete arg1;
16076     } catch (std::out_of_range& e) {
16077       {
16078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16079       };
16080     } catch (std::exception& e) {
16081       {
16082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16083       };
16084     } catch (...) {
16085       {
16086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16087       };
16088     }
16089   }
16090 }
16091
16092
16093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16094   void * jresult ;
16095   Dali::BaseHandle *arg1 = 0 ;
16096   Dali::BaseHandle *result = 0 ;
16097
16098   arg1 = (Dali::BaseHandle *)jarg1;
16099   if (!arg1) {
16100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16101     return 0;
16102   }
16103   {
16104     try {
16105       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16106     } catch (std::out_of_range& e) {
16107       {
16108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16109       };
16110     } catch (std::exception& e) {
16111       {
16112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16113       };
16114     } catch (...) {
16115       {
16116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16117       };
16118     }
16119   }
16120   jresult = (void *)result;
16121   return jresult;
16122 }
16123
16124
16125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16126   void * jresult ;
16127   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16128   Dali::BaseHandle *arg2 = 0 ;
16129   Dali::BaseHandle *result = 0 ;
16130
16131   arg1 = (Dali::BaseHandle *)jarg1;
16132   arg2 = (Dali::BaseHandle *)jarg2;
16133   if (!arg2) {
16134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16135     return 0;
16136   }
16137   {
16138     try {
16139       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16140     } catch (std::out_of_range& e) {
16141       {
16142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (std::exception& e) {
16145       {
16146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16147       };
16148     } catch (...) {
16149       {
16150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16151       };
16152     }
16153   }
16154   jresult = (void *)result;
16155   return jresult;
16156 }
16157
16158
16159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16160   unsigned int jresult ;
16161   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16162   std::string *arg2 = 0 ;
16163   Dali::Property::Map *arg3 = 0 ;
16164   bool result;
16165
16166   arg1 = (Dali::BaseHandle *)jarg1;
16167   if (!jarg2) {
16168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16169     return 0;
16170   }
16171   std::string arg2_str(jarg2);
16172   arg2 = &arg2_str;
16173   arg3 = (Dali::Property::Map *)jarg3;
16174   if (!arg3) {
16175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16176     return 0;
16177   }
16178   {
16179     try {
16180       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16181     } catch (std::out_of_range& e) {
16182       {
16183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16184       };
16185     } catch (std::exception& e) {
16186       {
16187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16188       };
16189     } catch (...) {
16190       {
16191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16192       };
16193     }
16194   }
16195   jresult = result;
16196
16197   //argout typemap for const std::string&
16198
16199   return jresult;
16200 }
16201
16202
16203 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16204   char * jresult ;
16205   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16206   std::string *result = 0 ;
16207
16208   arg1 = (Dali::BaseHandle *)jarg1;
16209   {
16210     try {
16211       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16212     } catch (std::out_of_range& e) {
16213       {
16214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16215       };
16216     } catch (std::exception& e) {
16217       {
16218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16219       };
16220     } catch (...) {
16221       {
16222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16223       };
16224     }
16225   }
16226   jresult = SWIG_csharp_string_callback(result->c_str());
16227   return jresult;
16228 }
16229
16230
16231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16232   unsigned int jresult ;
16233   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16234   Dali::TypeInfo *arg2 = 0 ;
16235   bool result;
16236
16237   arg1 = (Dali::BaseHandle *)jarg1;
16238   arg2 = (Dali::TypeInfo *)jarg2;
16239   if (!arg2) {
16240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16241     return 0;
16242   }
16243   {
16244     try {
16245       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16246     } catch (std::out_of_range& e) {
16247       {
16248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16249       };
16250     } catch (std::exception& e) {
16251       {
16252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16253       };
16254     } catch (...) {
16255       {
16256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16257       };
16258     }
16259   }
16260   jresult = result;
16261   return jresult;
16262 }
16263
16264
16265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16266   void * jresult ;
16267   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16268   Dali::BaseObject *result = 0 ;
16269
16270   arg1 = (Dali::BaseHandle *)jarg1;
16271   {
16272     try {
16273       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16274     } catch (std::out_of_range& e) {
16275       {
16276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16277       };
16278     } catch (std::exception& e) {
16279       {
16280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16281       };
16282     } catch (...) {
16283       {
16284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16285       };
16286     }
16287   }
16288   jresult = (void *)result;
16289   return jresult;
16290 }
16291
16292
16293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16294   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16295
16296   arg1 = (Dali::BaseHandle *)jarg1;
16297   {
16298     try {
16299       (arg1)->Reset();
16300     } catch (std::out_of_range& e) {
16301       {
16302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16303       };
16304     } catch (std::exception& e) {
16305       {
16306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16307       };
16308     } catch (...) {
16309       {
16310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16311       };
16312     }
16313   }
16314 }
16315
16316
16317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16318   unsigned int jresult ;
16319   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16320   Dali::BaseHandle *arg2 = 0 ;
16321   bool result;
16322
16323   arg1 = (Dali::BaseHandle *)jarg1;
16324   arg2 = (Dali::BaseHandle *)jarg2;
16325   if (!arg2) {
16326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16327     return 0;
16328   }
16329   {
16330     try {
16331       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16332     } catch (std::out_of_range& e) {
16333       {
16334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16335       };
16336     } catch (std::exception& e) {
16337       {
16338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16339       };
16340     } catch (...) {
16341       {
16342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16343       };
16344     }
16345   }
16346   jresult = result;
16347   return jresult;
16348 }
16349
16350
16351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16352   unsigned int jresult ;
16353   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16354   Dali::BaseHandle *arg2 = 0 ;
16355   bool result;
16356
16357   arg1 = (Dali::BaseHandle *)jarg1;
16358   arg2 = (Dali::BaseHandle *)jarg2;
16359   if (!arg2) {
16360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16361     return 0;
16362   }
16363   {
16364     try {
16365       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16366     } catch (std::out_of_range& e) {
16367       {
16368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16369       };
16370     } catch (std::exception& e) {
16371       {
16372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16373       };
16374     } catch (...) {
16375       {
16376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16377       };
16378     }
16379   }
16380   jresult = result;
16381   return jresult;
16382 }
16383
16384
16385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16386   void * jresult ;
16387   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16388   Dali::RefObject *result = 0 ;
16389
16390   arg1 = (Dali::BaseHandle *)jarg1;
16391   {
16392     try {
16393       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16394     } catch (std::out_of_range& e) {
16395       {
16396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16397       };
16398     } catch (std::exception& e) {
16399       {
16400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16401       };
16402     } catch (...) {
16403       {
16404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16405       };
16406     }
16407   }
16408   jresult = (void *)result;
16409   return jresult;
16410 }
16411
16412
16413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16414   unsigned int jresult ;
16415   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16416   bool result;
16417
16418   arg1 = (Dali::BaseHandle *)jarg1;
16419   {
16420     try {
16421       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16422     } catch (std::out_of_range& e) {
16423       {
16424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16425       };
16426     } catch (std::exception& e) {
16427       {
16428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16429       };
16430     } catch (...) {
16431       {
16432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16433       };
16434     }
16435   }
16436   jresult = result;
16437   return jresult;
16438 }
16439
16440
16441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16442   unsigned int jresult ;
16443   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16444   Dali::BaseHandle *arg2 = 0 ;
16445   bool result;
16446
16447   arg1 = (Dali::BaseHandle *)jarg1;
16448   arg2 = (Dali::BaseHandle *)jarg2;
16449   if (!arg2) {
16450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16451     return 0;
16452   }
16453   {
16454     try {
16455       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16456     } catch (std::out_of_range& e) {
16457       {
16458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16459       };
16460     } catch (std::exception& e) {
16461       {
16462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16463       };
16464     } catch (...) {
16465       {
16466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16467       };
16468     }
16469   }
16470   jresult = result;
16471   return jresult;
16472 }
16473
16474
16475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16476   unsigned int jresult ;
16477   Dali::BaseHandle *arg1 = 0 ;
16478   Dali::BaseHandle *arg2 = 0 ;
16479   bool result;
16480
16481   arg1 = (Dali::BaseHandle *)jarg1;
16482   if (!arg1) {
16483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16484     return 0;
16485   }
16486   arg2 = (Dali::BaseHandle *)jarg2;
16487   if (!arg2) {
16488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16489     return 0;
16490   }
16491   {
16492     try {
16493       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16494     } catch (std::out_of_range& e) {
16495       {
16496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16497       };
16498     } catch (std::exception& e) {
16499       {
16500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16501       };
16502     } catch (...) {
16503       {
16504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16505       };
16506     }
16507   }
16508   jresult = result;
16509   return jresult;
16510 }
16511
16512
16513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16514   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16515
16516   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16517   {
16518     try {
16519       delete arg1;
16520     } catch (std::out_of_range& e) {
16521       {
16522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16523       };
16524     } catch (std::exception& e) {
16525       {
16526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16527       };
16528     } catch (...) {
16529       {
16530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16531       };
16532     }
16533   }
16534 }
16535
16536
16537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16538   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16539   SlotObserver *arg2 = (SlotObserver *) 0 ;
16540   CallbackBase *arg3 = (CallbackBase *) 0 ;
16541
16542   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16543   arg2 = (SlotObserver *)jarg2;
16544   arg3 = (CallbackBase *)jarg3;
16545   {
16546     try {
16547       (arg1)->SignalConnected(arg2,arg3);
16548     } catch (std::out_of_range& e) {
16549       {
16550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16551       };
16552     } catch (std::exception& e) {
16553       {
16554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16555       };
16556     } catch (...) {
16557       {
16558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16559       };
16560     }
16561   }
16562 }
16563
16564
16565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16566   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16567
16568   arg1 = (Dali::SignalObserver *)jarg1;
16569   {
16570     try {
16571       delete arg1;
16572     } catch (std::out_of_range& e) {
16573       {
16574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16575       };
16576     } catch (std::exception& e) {
16577       {
16578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16579       };
16580     } catch (...) {
16581       {
16582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16583       };
16584     }
16585   }
16586 }
16587
16588
16589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16590   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16591   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16592   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16593
16594   arg1 = (Dali::SignalObserver *)jarg1;
16595   arg2 = (Dali::SlotObserver *)jarg2;
16596   arg3 = (Dali::CallbackBase *)jarg3;
16597   {
16598     try {
16599       (arg1)->SignalDisconnected(arg2,arg3);
16600     } catch (std::out_of_range& e) {
16601       {
16602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16603       };
16604     } catch (std::exception& e) {
16605       {
16606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16607       };
16608     } catch (...) {
16609       {
16610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16611       };
16612     }
16613   }
16614 }
16615
16616
16617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16618   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16619
16620   arg1 = (Dali::SlotObserver *)jarg1;
16621   {
16622     try {
16623       delete arg1;
16624     } catch (std::out_of_range& e) {
16625       {
16626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16627       };
16628     } catch (std::exception& e) {
16629       {
16630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16631       };
16632     } catch (...) {
16633       {
16634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16635       };
16636     }
16637   }
16638 }
16639
16640
16641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16642   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16643   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16644
16645   arg1 = (Dali::SlotObserver *)jarg1;
16646   arg2 = (Dali::CallbackBase *)jarg2;
16647   {
16648     try {
16649       (arg1)->SlotDisconnected(arg2);
16650     } catch (std::out_of_range& e) {
16651       {
16652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16653       };
16654     } catch (std::exception& e) {
16655       {
16656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16657       };
16658     } catch (...) {
16659       {
16660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16661       };
16662     }
16663   }
16664 }
16665
16666
16667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16668   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16669
16670   arg1 = (Dali::ConnectionTracker *)jarg1;
16671   {
16672     try {
16673       delete arg1;
16674     } catch (std::out_of_range& e) {
16675       {
16676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16677       };
16678     } catch (std::exception& e) {
16679       {
16680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16681       };
16682     } catch (...) {
16683       {
16684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16685       };
16686     }
16687   }
16688 }
16689
16690
16691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16692   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16693
16694   arg1 = (Dali::ConnectionTracker *)jarg1;
16695   {
16696     try {
16697       (arg1)->DisconnectAll();
16698     } catch (std::out_of_range& e) {
16699       {
16700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16701       };
16702     } catch (std::exception& e) {
16703       {
16704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16705       };
16706     } catch (...) {
16707       {
16708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16709       };
16710     }
16711   }
16712 }
16713
16714
16715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16716   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16717   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16718   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16719
16720   arg1 = (Dali::ConnectionTracker *)jarg1;
16721   arg2 = (Dali::SlotObserver *)jarg2;
16722   arg3 = (Dali::CallbackBase *)jarg3;
16723   {
16724     try {
16725       (arg1)->SignalConnected(arg2,arg3);
16726     } catch (std::out_of_range& e) {
16727       {
16728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16729       };
16730     } catch (std::exception& e) {
16731       {
16732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16733       };
16734     } catch (...) {
16735       {
16736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16737       };
16738     }
16739   }
16740 }
16741
16742
16743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16744   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16745   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16746   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16747
16748   arg1 = (Dali::ConnectionTracker *)jarg1;
16749   arg2 = (Dali::SlotObserver *)jarg2;
16750   arg3 = (Dali::CallbackBase *)jarg3;
16751   {
16752     try {
16753       (arg1)->SignalDisconnected(arg2,arg3);
16754     } catch (std::out_of_range& e) {
16755       {
16756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16757       };
16758     } catch (std::exception& e) {
16759       {
16760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16761       };
16762     } catch (...) {
16763       {
16764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16765       };
16766     }
16767   }
16768 }
16769
16770
16771 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16772   unsigned long jresult ;
16773   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16774   std::size_t result;
16775
16776   arg1 = (Dali::ConnectionTracker *)jarg1;
16777   {
16778     try {
16779       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16780     } catch (std::out_of_range& e) {
16781       {
16782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16783       };
16784     } catch (std::exception& e) {
16785       {
16786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16787       };
16788     } catch (...) {
16789       {
16790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16791       };
16792     }
16793   }
16794   jresult = (unsigned long)result;
16795   return jresult;
16796 }
16797
16798
16799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16800   void * jresult ;
16801   Dali::ObjectRegistry *result = 0 ;
16802
16803   {
16804     try {
16805       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16806     } catch (std::out_of_range& e) {
16807       {
16808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16809       };
16810     } catch (std::exception& e) {
16811       {
16812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16813       };
16814     } catch (...) {
16815       {
16816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16817       };
16818     }
16819   }
16820   jresult = (void *)result;
16821   return jresult;
16822 }
16823
16824
16825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16826   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16827
16828   arg1 = (Dali::ObjectRegistry *)jarg1;
16829   {
16830     try {
16831       delete arg1;
16832     } catch (std::out_of_range& e) {
16833       {
16834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16835       };
16836     } catch (std::exception& e) {
16837       {
16838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16839       };
16840     } catch (...) {
16841       {
16842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16843       };
16844     }
16845   }
16846 }
16847
16848
16849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16850   void * jresult ;
16851   Dali::ObjectRegistry *arg1 = 0 ;
16852   Dali::ObjectRegistry *result = 0 ;
16853
16854   arg1 = (Dali::ObjectRegistry *)jarg1;
16855   if (!arg1) {
16856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16857     return 0;
16858   }
16859   {
16860     try {
16861       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16862     } catch (std::out_of_range& e) {
16863       {
16864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16865       };
16866     } catch (std::exception& e) {
16867       {
16868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16869       };
16870     } catch (...) {
16871       {
16872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16873       };
16874     }
16875   }
16876   jresult = (void *)result;
16877   return jresult;
16878 }
16879
16880
16881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16882   void * jresult ;
16883   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16884   Dali::ObjectRegistry *arg2 = 0 ;
16885   Dali::ObjectRegistry *result = 0 ;
16886
16887   arg1 = (Dali::ObjectRegistry *)jarg1;
16888   arg2 = (Dali::ObjectRegistry *)jarg2;
16889   if (!arg2) {
16890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16891     return 0;
16892   }
16893   {
16894     try {
16895       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16896     } catch (std::out_of_range& e) {
16897       {
16898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16899       };
16900     } catch (std::exception& e) {
16901       {
16902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16903       };
16904     } catch (...) {
16905       {
16906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16907       };
16908     }
16909   }
16910   jresult = (void *)result;
16911   return jresult;
16912 }
16913
16914
16915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16916   void * jresult ;
16917   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16918   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16919
16920   arg1 = (Dali::ObjectRegistry *)jarg1;
16921   {
16922     try {
16923       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16924     } catch (std::out_of_range& e) {
16925       {
16926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16927       };
16928     } catch (std::exception& e) {
16929       {
16930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16931       };
16932     } catch (...) {
16933       {
16934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16935       };
16936     }
16937   }
16938   jresult = (void *)result;
16939   return jresult;
16940 }
16941
16942
16943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16944   void * jresult ;
16945   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16946   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16947
16948   arg1 = (Dali::ObjectRegistry *)jarg1;
16949   {
16950     try {
16951       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16952     } catch (std::out_of_range& e) {
16953       {
16954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16955       };
16956     } catch (std::exception& e) {
16957       {
16958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16959       };
16960     } catch (...) {
16961       {
16962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16963       };
16964     }
16965   }
16966   jresult = (void *)result;
16967   return jresult;
16968 }
16969
16970
16971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
16972   void * jresult ;
16973   Dali::PropertyCondition *result = 0 ;
16974
16975   {
16976     try {
16977       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
16978     } catch (std::out_of_range& e) {
16979       {
16980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16981       };
16982     } catch (std::exception& e) {
16983       {
16984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16985       };
16986     } catch (...) {
16987       {
16988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16989       };
16990     }
16991   }
16992   jresult = (void *)result;
16993   return jresult;
16994 }
16995
16996
16997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
16998   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
16999
17000   arg1 = (Dali::PropertyCondition *)jarg1;
17001   {
17002     try {
17003       delete arg1;
17004     } catch (std::out_of_range& e) {
17005       {
17006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17007       };
17008     } catch (std::exception& e) {
17009       {
17010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17011       };
17012     } catch (...) {
17013       {
17014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17015       };
17016     }
17017   }
17018 }
17019
17020
17021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17022   void * jresult ;
17023   Dali::PropertyCondition *arg1 = 0 ;
17024   Dali::PropertyCondition *result = 0 ;
17025
17026   arg1 = (Dali::PropertyCondition *)jarg1;
17027   if (!arg1) {
17028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17029     return 0;
17030   }
17031   {
17032     try {
17033       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17034     } catch (std::out_of_range& e) {
17035       {
17036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17037       };
17038     } catch (std::exception& e) {
17039       {
17040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17041       };
17042     } catch (...) {
17043       {
17044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17045       };
17046     }
17047   }
17048   jresult = (void *)result;
17049   return jresult;
17050 }
17051
17052
17053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17054   void * jresult ;
17055   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17056   Dali::PropertyCondition *arg2 = 0 ;
17057   Dali::PropertyCondition *result = 0 ;
17058
17059   arg1 = (Dali::PropertyCondition *)jarg1;
17060   arg2 = (Dali::PropertyCondition *)jarg2;
17061   if (!arg2) {
17062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17063     return 0;
17064   }
17065   {
17066     try {
17067       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17068     } catch (std::out_of_range& e) {
17069       {
17070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17071       };
17072     } catch (std::exception& e) {
17073       {
17074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17075       };
17076     } catch (...) {
17077       {
17078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17079       };
17080     }
17081   }
17082   jresult = (void *)result;
17083   return jresult;
17084 }
17085
17086
17087 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17088   unsigned long jresult ;
17089   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17090   std::size_t result;
17091
17092   arg1 = (Dali::PropertyCondition *)jarg1;
17093   {
17094     try {
17095       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17096     } catch (std::out_of_range& e) {
17097       {
17098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17099       };
17100     } catch (std::exception& e) {
17101       {
17102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17103       };
17104     } catch (...) {
17105       {
17106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17107       };
17108     }
17109   }
17110   jresult = (unsigned long)result;
17111   return jresult;
17112 }
17113
17114
17115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17116   float jresult ;
17117   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17118   std::size_t arg2 ;
17119   float result;
17120
17121   arg1 = (Dali::PropertyCondition *)jarg1;
17122   arg2 = (std::size_t)jarg2;
17123   {
17124     try {
17125       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17126     } catch (std::out_of_range& e) {
17127       {
17128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17129       };
17130     } catch (std::exception& e) {
17131       {
17132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17133       };
17134     } catch (...) {
17135       {
17136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17137       };
17138     }
17139   }
17140   jresult = result;
17141   return jresult;
17142 }
17143
17144
17145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17146   void * jresult ;
17147   float arg1 ;
17148   Dali::PropertyCondition result;
17149
17150   arg1 = (float)jarg1;
17151   {
17152     try {
17153       result = Dali::LessThanCondition(arg1);
17154     } catch (std::out_of_range& e) {
17155       {
17156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17157       };
17158     } catch (std::exception& e) {
17159       {
17160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17161       };
17162     } catch (...) {
17163       {
17164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17165       };
17166     }
17167   }
17168   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17169   return jresult;
17170 }
17171
17172
17173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17174   void * jresult ;
17175   float arg1 ;
17176   Dali::PropertyCondition result;
17177
17178   arg1 = (float)jarg1;
17179   {
17180     try {
17181       result = Dali::GreaterThanCondition(arg1);
17182     } catch (std::out_of_range& e) {
17183       {
17184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17185       };
17186     } catch (std::exception& e) {
17187       {
17188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17189       };
17190     } catch (...) {
17191       {
17192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17193       };
17194     }
17195   }
17196   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17197   return jresult;
17198 }
17199
17200
17201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17202   void * jresult ;
17203   float arg1 ;
17204   float arg2 ;
17205   Dali::PropertyCondition result;
17206
17207   arg1 = (float)jarg1;
17208   arg2 = (float)jarg2;
17209   {
17210     try {
17211       result = Dali::InsideCondition(arg1,arg2);
17212     } catch (std::out_of_range& e) {
17213       {
17214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17215       };
17216     } catch (std::exception& e) {
17217       {
17218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17219       };
17220     } catch (...) {
17221       {
17222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17223       };
17224     }
17225   }
17226   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17227   return jresult;
17228 }
17229
17230
17231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17232   void * jresult ;
17233   float arg1 ;
17234   float arg2 ;
17235   Dali::PropertyCondition result;
17236
17237   arg1 = (float)jarg1;
17238   arg2 = (float)jarg2;
17239   {
17240     try {
17241       result = Dali::OutsideCondition(arg1,arg2);
17242     } catch (std::out_of_range& e) {
17243       {
17244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17245       };
17246     } catch (std::exception& e) {
17247       {
17248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17249       };
17250     } catch (...) {
17251       {
17252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17253       };
17254     }
17255   }
17256   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17257   return jresult;
17258 }
17259
17260
17261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17262   void * jresult ;
17263   float arg1 ;
17264   float arg2 ;
17265   Dali::PropertyCondition result;
17266
17267   arg1 = (float)jarg1;
17268   arg2 = (float)jarg2;
17269   {
17270     try {
17271       result = Dali::StepCondition(arg1,arg2);
17272     } catch (std::out_of_range& e) {
17273       {
17274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17275       };
17276     } catch (std::exception& e) {
17277       {
17278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17279       };
17280     } catch (...) {
17281       {
17282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17283       };
17284     }
17285   }
17286   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17287   return jresult;
17288 }
17289
17290
17291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17292   void * jresult ;
17293   float arg1 ;
17294   Dali::PropertyCondition result;
17295
17296   arg1 = (float)jarg1;
17297   {
17298     try {
17299       result = Dali::StepCondition(arg1);
17300     } catch (std::out_of_range& e) {
17301       {
17302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17303       };
17304     } catch (std::exception& e) {
17305       {
17306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (...) {
17309       {
17310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17311       };
17312     }
17313   }
17314   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17315   return jresult;
17316 }
17317
17318
17319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17320   void * jresult ;
17321   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17322   Dali::PropertyCondition result;
17323
17324   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17325   if (!arg1) {
17326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17327     return 0;
17328   }
17329   {
17330     try {
17331       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17332     } catch (std::out_of_range& e) {
17333       {
17334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17335       };
17336     } catch (std::exception& e) {
17337       {
17338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17339       };
17340     } catch (...) {
17341       {
17342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17343       };
17344     }
17345   }
17346   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17347   return jresult;
17348 }
17349
17350
17351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17352   void * jresult ;
17353   Dali::PropertyNotification *result = 0 ;
17354
17355   {
17356     try {
17357       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17358     } catch (std::out_of_range& e) {
17359       {
17360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17361       };
17362     } catch (std::exception& e) {
17363       {
17364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17365       };
17366     } catch (...) {
17367       {
17368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17369       };
17370     }
17371   }
17372   jresult = (void *)result;
17373   return jresult;
17374 }
17375
17376
17377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17378   void * jresult ;
17379   Dali::BaseHandle arg1 ;
17380   Dali::BaseHandle *argp1 ;
17381   Dali::PropertyNotification result;
17382
17383   argp1 = (Dali::BaseHandle *)jarg1;
17384   if (!argp1) {
17385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17386     return 0;
17387   }
17388   arg1 = *argp1;
17389   {
17390     try {
17391       result = Dali::PropertyNotification::DownCast(arg1);
17392     } catch (std::out_of_range& e) {
17393       {
17394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17395       };
17396     } catch (std::exception& e) {
17397       {
17398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17399       };
17400     } catch (...) {
17401       {
17402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17403       };
17404     }
17405   }
17406   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17407   return jresult;
17408 }
17409
17410
17411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17412   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17413
17414   arg1 = (Dali::PropertyNotification *)jarg1;
17415   {
17416     try {
17417       delete arg1;
17418     } catch (std::out_of_range& e) {
17419       {
17420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17421       };
17422     } catch (std::exception& e) {
17423       {
17424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17425       };
17426     } catch (...) {
17427       {
17428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17429       };
17430     }
17431   }
17432 }
17433
17434
17435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17436   void * jresult ;
17437   Dali::PropertyNotification *arg1 = 0 ;
17438   Dali::PropertyNotification *result = 0 ;
17439
17440   arg1 = (Dali::PropertyNotification *)jarg1;
17441   if (!arg1) {
17442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17443     return 0;
17444   }
17445   {
17446     try {
17447       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
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 = (void *)result;
17463   return jresult;
17464 }
17465
17466
17467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17468   void * jresult ;
17469   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17470   Dali::PropertyNotification *arg2 = 0 ;
17471   Dali::PropertyNotification *result = 0 ;
17472
17473   arg1 = (Dali::PropertyNotification *)jarg1;
17474   arg2 = (Dali::PropertyNotification *)jarg2;
17475   if (!arg2) {
17476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17477     return 0;
17478   }
17479   {
17480     try {
17481       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17482     } catch (std::out_of_range& e) {
17483       {
17484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17485       };
17486     } catch (std::exception& e) {
17487       {
17488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17489       };
17490     } catch (...) {
17491       {
17492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17493       };
17494     }
17495   }
17496   jresult = (void *)result;
17497   return jresult;
17498 }
17499
17500
17501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17502   void * jresult ;
17503   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17504   Dali::PropertyCondition result;
17505
17506   arg1 = (Dali::PropertyNotification *)jarg1;
17507   {
17508     try {
17509       result = (arg1)->GetCondition();
17510     } catch (std::out_of_range& e) {
17511       {
17512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17513       };
17514     } catch (std::exception& e) {
17515       {
17516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17517       };
17518     } catch (...) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17521       };
17522     }
17523   }
17524   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17525   return jresult;
17526 }
17527
17528
17529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17530   void * jresult ;
17531   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17532   Dali::Handle result;
17533
17534   arg1 = (Dali::PropertyNotification *)jarg1;
17535   {
17536     try {
17537       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17538     } catch (std::out_of_range& e) {
17539       {
17540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17541       };
17542     } catch (std::exception& e) {
17543       {
17544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17545       };
17546     } catch (...) {
17547       {
17548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17549       };
17550     }
17551   }
17552   jresult = new Dali::Handle((const Dali::Handle &)result);
17553   return jresult;
17554 }
17555
17556
17557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17558   int jresult ;
17559   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17560   Dali::Property::Index result;
17561
17562   arg1 = (Dali::PropertyNotification *)jarg1;
17563   {
17564     try {
17565       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17566     } catch (std::out_of_range& e) {
17567       {
17568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17569       };
17570     } catch (std::exception& e) {
17571       {
17572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17573       };
17574     } catch (...) {
17575       {
17576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17577       };
17578     }
17579   }
17580   jresult = result;
17581   return jresult;
17582 }
17583
17584
17585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17586   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17587   Dali::PropertyNotification::NotifyMode arg2 ;
17588
17589   arg1 = (Dali::PropertyNotification *)jarg1;
17590   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17591   {
17592     try {
17593       (arg1)->SetNotifyMode(arg2);
17594     } catch (std::out_of_range& e) {
17595       {
17596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17597       };
17598     } catch (std::exception& e) {
17599       {
17600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17601       };
17602     } catch (...) {
17603       {
17604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17605       };
17606     }
17607   }
17608 }
17609
17610
17611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17612   int jresult ;
17613   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17614   Dali::PropertyNotification::NotifyMode result;
17615
17616   arg1 = (Dali::PropertyNotification *)jarg1;
17617   {
17618     try {
17619       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17620     } catch (std::out_of_range& e) {
17621       {
17622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17623       };
17624     } catch (std::exception& e) {
17625       {
17626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17627       };
17628     } catch (...) {
17629       {
17630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17631       };
17632     }
17633   }
17634   jresult = (int)result;
17635   return jresult;
17636 }
17637
17638
17639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17640   unsigned int jresult ;
17641   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17642   bool result;
17643
17644   arg1 = (Dali::PropertyNotification *)jarg1;
17645   {
17646     try {
17647       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17648     } catch (std::out_of_range& e) {
17649       {
17650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17651       };
17652     } catch (std::exception& e) {
17653       {
17654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17655       };
17656     } catch (...) {
17657       {
17658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17659       };
17660     }
17661   }
17662   jresult = result;
17663   return jresult;
17664 }
17665
17666
17667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17668   void * jresult ;
17669   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17670   Dali::PropertyNotifySignalType *result = 0 ;
17671
17672   arg1 = (Dali::PropertyNotification *)jarg1;
17673   {
17674     try {
17675       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17676     } catch (std::out_of_range& e) {
17677       {
17678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17679       };
17680     } catch (std::exception& e) {
17681       {
17682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17683       };
17684     } catch (...) {
17685       {
17686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17687       };
17688     }
17689   }
17690   jresult = (void *)result;
17691   return jresult;
17692 }
17693
17694
17695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17696   void * jresult ;
17697   Dali::Handle *result = 0 ;
17698
17699   {
17700     try {
17701       result = (Dali::Handle *)new Dali::Handle();
17702     } catch (std::out_of_range& e) {
17703       {
17704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17705       };
17706     } catch (std::exception& e) {
17707       {
17708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17709       };
17710     } catch (...) {
17711       {
17712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17713       };
17714     }
17715   }
17716   jresult = (void *)result;
17717   return jresult;
17718 }
17719
17720
17721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17722   void * jresult ;
17723   Dali::Handle result;
17724
17725   {
17726     try {
17727       result = Dali::Handle::New();
17728     } catch (std::out_of_range& e) {
17729       {
17730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17731       };
17732     } catch (std::exception& e) {
17733       {
17734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17735       };
17736     } catch (...) {
17737       {
17738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17739       };
17740     }
17741   }
17742   jresult = new Dali::Handle((const Dali::Handle &)result);
17743   return jresult;
17744 }
17745
17746
17747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17748   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17749
17750   arg1 = (Dali::Handle *)jarg1;
17751   {
17752     try {
17753       delete arg1;
17754     } catch (std::out_of_range& e) {
17755       {
17756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17757       };
17758     } catch (std::exception& e) {
17759       {
17760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17761       };
17762     } catch (...) {
17763       {
17764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17765       };
17766     }
17767   }
17768 }
17769
17770
17771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17772   void * jresult ;
17773   Dali::Handle *arg1 = 0 ;
17774   Dali::Handle *result = 0 ;
17775
17776   arg1 = (Dali::Handle *)jarg1;
17777   if (!arg1) {
17778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17779     return 0;
17780   }
17781   {
17782     try {
17783       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17784     } catch (std::out_of_range& e) {
17785       {
17786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17787       };
17788     } catch (std::exception& e) {
17789       {
17790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17791       };
17792     } catch (...) {
17793       {
17794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17795       };
17796     }
17797   }
17798   jresult = (void *)result;
17799   return jresult;
17800 }
17801
17802
17803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17804   void * jresult ;
17805   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17806   Dali::Handle *arg2 = 0 ;
17807   Dali::Handle *result = 0 ;
17808
17809   arg1 = (Dali::Handle *)jarg1;
17810   arg2 = (Dali::Handle *)jarg2;
17811   if (!arg2) {
17812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17813     return 0;
17814   }
17815   {
17816     try {
17817       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17818     } catch (std::out_of_range& e) {
17819       {
17820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17821       };
17822     } catch (std::exception& e) {
17823       {
17824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17825       };
17826     } catch (...) {
17827       {
17828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17829       };
17830     }
17831   }
17832   jresult = (void *)result;
17833   return jresult;
17834 }
17835
17836
17837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17838   void * jresult ;
17839   Dali::BaseHandle arg1 ;
17840   Dali::BaseHandle *argp1 ;
17841   Dali::Handle result;
17842
17843   argp1 = (Dali::BaseHandle *)jarg1;
17844   if (!argp1) {
17845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17846     return 0;
17847   }
17848   arg1 = *argp1;
17849   {
17850     try {
17851       result = Dali::Handle::DownCast(arg1);
17852     } catch (std::out_of_range& e) {
17853       {
17854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17855       };
17856     } catch (std::exception& e) {
17857       {
17858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17859       };
17860     } catch (...) {
17861       {
17862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17863       };
17864     }
17865   }
17866   jresult = new Dali::Handle((const Dali::Handle &)result);
17867   return jresult;
17868 }
17869
17870
17871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17872   unsigned int jresult ;
17873   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17874   Dali::Handle::Capability arg2 ;
17875   bool result;
17876
17877   arg1 = (Dali::Handle *)jarg1;
17878   arg2 = (Dali::Handle::Capability)jarg2;
17879   {
17880     try {
17881       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17882     } catch (std::out_of_range& e) {
17883       {
17884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17885       };
17886     } catch (std::exception& e) {
17887       {
17888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17889       };
17890     } catch (...) {
17891       {
17892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17893       };
17894     }
17895   }
17896   jresult = result;
17897   return jresult;
17898 }
17899
17900
17901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17902   unsigned int jresult ;
17903   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17904   unsigned int result;
17905
17906   arg1 = (Dali::Handle *)jarg1;
17907   {
17908     try {
17909       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17910     } catch (std::out_of_range& e) {
17911       {
17912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17913       };
17914     } catch (std::exception& e) {
17915       {
17916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17917       };
17918     } catch (...) {
17919       {
17920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17921       };
17922     }
17923   }
17924   jresult = result;
17925   return jresult;
17926 }
17927
17928
17929 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17930   char * jresult ;
17931   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17932   Dali::Property::Index arg2 ;
17933   std::string result;
17934
17935   arg1 = (Dali::Handle *)jarg1;
17936   arg2 = (Dali::Property::Index)jarg2;
17937   {
17938     try {
17939       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17940     } catch (std::out_of_range& e) {
17941       {
17942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17943       };
17944     } catch (std::exception& e) {
17945       {
17946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17947       };
17948     } catch (...) {
17949       {
17950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17951       };
17952     }
17953   }
17954   jresult = SWIG_csharp_string_callback((&result)->c_str());
17955   return jresult;
17956 }
17957
17958
17959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17960   int jresult ;
17961   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17962   std::string *arg2 = 0 ;
17963   Dali::Property::Index result;
17964
17965   arg1 = (Dali::Handle *)jarg1;
17966   if (!jarg2) {
17967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17968     return 0;
17969   }
17970   std::string arg2_str(jarg2);
17971   arg2 = &arg2_str;
17972   {
17973     try {
17974       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
17975     } catch (std::out_of_range& e) {
17976       {
17977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17978       };
17979     } catch (std::exception& e) {
17980       {
17981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17982       };
17983     } catch (...) {
17984       {
17985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17986       };
17987     }
17988   }
17989   jresult = result;
17990
17991   //argout typemap for const std::string&
17992
17993   return jresult;
17994 }
17995
17996
17997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
17998   unsigned int jresult ;
17999   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18000   Dali::Property::Index arg2 ;
18001   bool result;
18002
18003   arg1 = (Dali::Handle *)jarg1;
18004   arg2 = (Dali::Property::Index)jarg2;
18005   {
18006     try {
18007       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18008     } catch (std::out_of_range& e) {
18009       {
18010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18011       };
18012     } catch (std::exception& e) {
18013       {
18014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18015       };
18016     } catch (...) {
18017       {
18018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18019       };
18020     }
18021   }
18022   jresult = result;
18023   return jresult;
18024 }
18025
18026
18027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18028   unsigned int jresult ;
18029   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18030   Dali::Property::Index arg2 ;
18031   bool result;
18032
18033   arg1 = (Dali::Handle *)jarg1;
18034   arg2 = (Dali::Property::Index)jarg2;
18035   {
18036     try {
18037       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18038     } catch (std::out_of_range& e) {
18039       {
18040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18041       };
18042     } catch (std::exception& e) {
18043       {
18044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18045       };
18046     } catch (...) {
18047       {
18048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18049       };
18050     }
18051   }
18052   jresult = result;
18053   return jresult;
18054 }
18055
18056
18057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18058   unsigned int jresult ;
18059   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18060   Dali::Property::Index arg2 ;
18061   bool result;
18062
18063   arg1 = (Dali::Handle *)jarg1;
18064   arg2 = (Dali::Property::Index)jarg2;
18065   {
18066     try {
18067       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18068     } catch (std::out_of_range& e) {
18069       {
18070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18071       };
18072     } catch (std::exception& e) {
18073       {
18074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18075       };
18076     } catch (...) {
18077       {
18078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18079       };
18080     }
18081   }
18082   jresult = result;
18083   return jresult;
18084 }
18085
18086
18087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18088   int jresult ;
18089   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18090   Dali::Property::Index arg2 ;
18091   Dali::Property::Type result;
18092
18093   arg1 = (Dali::Handle *)jarg1;
18094   arg2 = (Dali::Property::Index)jarg2;
18095   {
18096     try {
18097       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18098     } catch (std::out_of_range& e) {
18099       {
18100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18101       };
18102     } catch (std::exception& e) {
18103       {
18104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18105       };
18106     } catch (...) {
18107       {
18108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18109       };
18110     }
18111   }
18112   jresult = (int)result;
18113   return jresult;
18114 }
18115
18116
18117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18118   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18119   Dali::Property::Index arg2 ;
18120   Dali::Property::Value *arg3 = 0 ;
18121
18122   arg1 = (Dali::Handle *)jarg1;
18123   arg2 = (Dali::Property::Index)jarg2;
18124   arg3 = (Dali::Property::Value *)jarg3;
18125   if (!arg3) {
18126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18127     return ;
18128   }
18129   {
18130     try {
18131       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18132     } catch (std::out_of_range& e) {
18133       {
18134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18135       };
18136     } catch (std::exception& e) {
18137       {
18138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18139       };
18140     } catch (...) {
18141       {
18142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18143       };
18144     }
18145   }
18146 }
18147
18148
18149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18150   int jresult ;
18151   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18152   std::string *arg2 = 0 ;
18153   Dali::Property::Value *arg3 = 0 ;
18154   Dali::Property::Index result;
18155
18156   arg1 = (Dali::Handle *)jarg1;
18157   if (!jarg2) {
18158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18159     return 0;
18160   }
18161   std::string arg2_str(jarg2);
18162   arg2 = &arg2_str;
18163   arg3 = (Dali::Property::Value *)jarg3;
18164   if (!arg3) {
18165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18166     return 0;
18167   }
18168   {
18169     try {
18170       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18171     } catch (std::out_of_range& e) {
18172       {
18173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18174       };
18175     } catch (std::exception& e) {
18176       {
18177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18178       };
18179     } catch (...) {
18180       {
18181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18182       };
18183     }
18184   }
18185   jresult = result;
18186
18187   //argout typemap for const std::string&
18188
18189   return jresult;
18190 }
18191
18192
18193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18194   int jresult ;
18195   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18196   std::string *arg2 = 0 ;
18197   Dali::Property::Value *arg3 = 0 ;
18198   Dali::Property::AccessMode arg4 ;
18199   Dali::Property::Index result;
18200
18201   arg1 = (Dali::Handle *)jarg1;
18202   if (!jarg2) {
18203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18204     return 0;
18205   }
18206   std::string arg2_str(jarg2);
18207   arg2 = &arg2_str;
18208   arg3 = (Dali::Property::Value *)jarg3;
18209   if (!arg3) {
18210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18211     return 0;
18212   }
18213   arg4 = (Dali::Property::AccessMode)jarg4;
18214   {
18215     try {
18216       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18217     } catch (std::out_of_range& e) {
18218       {
18219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18220       };
18221     } catch (std::exception& e) {
18222       {
18223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18224       };
18225     } catch (...) {
18226       {
18227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18228       };
18229     }
18230   }
18231   jresult = result;
18232
18233   //argout typemap for const std::string&
18234
18235   return jresult;
18236 }
18237
18238
18239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18240   void * jresult ;
18241   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18242   Dali::Property::Index arg2 ;
18243   Dali::Property::Value result;
18244
18245   arg1 = (Dali::Handle *)jarg1;
18246   arg2 = (Dali::Property::Index)jarg2;
18247   {
18248     try {
18249       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18250     } catch (std::out_of_range& e) {
18251       {
18252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18253       };
18254     } catch (std::exception& e) {
18255       {
18256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18257       };
18258     } catch (...) {
18259       {
18260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18261       };
18262     }
18263   }
18264   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18265   return jresult;
18266 }
18267
18268
18269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18270   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18271   Dali::Property::IndexContainer *arg2 = 0 ;
18272
18273   arg1 = (Dali::Handle *)jarg1;
18274   arg2 = (Dali::Property::IndexContainer *)jarg2;
18275   if (!arg2) {
18276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18277     return ;
18278   }
18279   {
18280     try {
18281       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18282     } catch (std::out_of_range& e) {
18283       {
18284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18285       };
18286     } catch (std::exception& e) {
18287       {
18288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18289       };
18290     } catch (...) {
18291       {
18292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18293       };
18294     }
18295   }
18296 }
18297
18298
18299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18300   void * jresult ;
18301   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18302   Dali::Property::Index arg2 ;
18303   Dali::PropertyCondition *arg3 = 0 ;
18304   Dali::PropertyNotification result;
18305
18306   arg1 = (Dali::Handle *)jarg1;
18307   arg2 = (Dali::Property::Index)jarg2;
18308   arg3 = (Dali::PropertyCondition *)jarg3;
18309   if (!arg3) {
18310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18311     return 0;
18312   }
18313   {
18314     try {
18315       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18316     } catch (std::out_of_range& e) {
18317       {
18318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18319       };
18320     } catch (std::exception& e) {
18321       {
18322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18323       };
18324     } catch (...) {
18325       {
18326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18327       };
18328     }
18329   }
18330   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18331   return jresult;
18332 }
18333
18334
18335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18336   void * jresult ;
18337   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18338   Dali::Property::Index arg2 ;
18339   int arg3 ;
18340   Dali::PropertyCondition *arg4 = 0 ;
18341   Dali::PropertyNotification result;
18342
18343   arg1 = (Dali::Handle *)jarg1;
18344   arg2 = (Dali::Property::Index)jarg2;
18345   arg3 = (int)jarg3;
18346   arg4 = (Dali::PropertyCondition *)jarg4;
18347   if (!arg4) {
18348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18349     return 0;
18350   }
18351   {
18352     try {
18353       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18354     } catch (std::out_of_range& e) {
18355       {
18356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18357       };
18358     } catch (std::exception& e) {
18359       {
18360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18361       };
18362     } catch (...) {
18363       {
18364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18365       };
18366     }
18367   }
18368   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18369   return jresult;
18370 }
18371
18372
18373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18374   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18375   Dali::PropertyNotification arg2 ;
18376   Dali::PropertyNotification *argp2 ;
18377
18378   arg1 = (Dali::Handle *)jarg1;
18379   argp2 = (Dali::PropertyNotification *)jarg2;
18380   if (!argp2) {
18381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18382     return ;
18383   }
18384   arg2 = *argp2;
18385   {
18386     try {
18387       (arg1)->RemovePropertyNotification(arg2);
18388     } catch (std::out_of_range& e) {
18389       {
18390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18391       };
18392     } catch (std::exception& e) {
18393       {
18394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18395       };
18396     } catch (...) {
18397       {
18398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18399       };
18400     }
18401   }
18402 }
18403
18404
18405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18406   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18407
18408   arg1 = (Dali::Handle *)jarg1;
18409   {
18410     try {
18411       (arg1)->RemovePropertyNotifications();
18412     } catch (std::out_of_range& e) {
18413       {
18414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18415       };
18416     } catch (std::exception& e) {
18417       {
18418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18419       };
18420     } catch (...) {
18421       {
18422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18423       };
18424     }
18425   }
18426 }
18427
18428
18429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18430   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18431
18432   arg1 = (Dali::Handle *)jarg1;
18433   {
18434     try {
18435       (arg1)->RemoveConstraints();
18436     } catch (std::out_of_range& e) {
18437       {
18438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18439       };
18440     } catch (std::exception& e) {
18441       {
18442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18443       };
18444     } catch (...) {
18445       {
18446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18447       };
18448     }
18449   }
18450 }
18451
18452
18453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18454   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18455   unsigned int arg2 ;
18456
18457   arg1 = (Dali::Handle *)jarg1;
18458   arg2 = (unsigned int)jarg2;
18459   {
18460     try {
18461       (arg1)->RemoveConstraints(arg2);
18462     } catch (std::out_of_range& e) {
18463       {
18464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18465       };
18466     } catch (std::exception& e) {
18467       {
18468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18469       };
18470     } catch (...) {
18471       {
18472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18473       };
18474     }
18475   }
18476 }
18477
18478
18479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18480   int jresult ;
18481   Dali::Property::Index result;
18482
18483   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18484   jresult = result;
18485   return jresult;
18486 }
18487
18488
18489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18490   void * jresult ;
18491   Dali::Handle result;
18492
18493   {
18494     try {
18495       result = Dali::WeightObject::New();
18496     } catch (std::out_of_range& e) {
18497       {
18498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18499       };
18500     } catch (std::exception& e) {
18501       {
18502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18503       };
18504     } catch (...) {
18505       {
18506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18507       };
18508     }
18509   }
18510   jresult = new Dali::Handle((const Dali::Handle &)result);
18511   return jresult;
18512 }
18513
18514
18515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18516   void * jresult ;
18517   Dali::TypeInfo *result = 0 ;
18518
18519   {
18520     try {
18521       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18522     } catch (std::out_of_range& e) {
18523       {
18524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18525       };
18526     } catch (std::exception& e) {
18527       {
18528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18529       };
18530     } catch (...) {
18531       {
18532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18533       };
18534     }
18535   }
18536   jresult = (void *)result;
18537   return jresult;
18538 }
18539
18540
18541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18542   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18543
18544   arg1 = (Dali::TypeInfo *)jarg1;
18545   {
18546     try {
18547       delete arg1;
18548     } catch (std::out_of_range& e) {
18549       {
18550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18551       };
18552     } catch (std::exception& e) {
18553       {
18554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18555       };
18556     } catch (...) {
18557       {
18558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18559       };
18560     }
18561   }
18562 }
18563
18564
18565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18566   void * jresult ;
18567   Dali::TypeInfo *arg1 = 0 ;
18568   Dali::TypeInfo *result = 0 ;
18569
18570   arg1 = (Dali::TypeInfo *)jarg1;
18571   if (!arg1) {
18572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18573     return 0;
18574   }
18575   {
18576     try {
18577       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18578     } catch (std::out_of_range& e) {
18579       {
18580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18581       };
18582     } catch (std::exception& e) {
18583       {
18584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18585       };
18586     } catch (...) {
18587       {
18588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18589       };
18590     }
18591   }
18592   jresult = (void *)result;
18593   return jresult;
18594 }
18595
18596
18597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18598   void * jresult ;
18599   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18600   Dali::TypeInfo *arg2 = 0 ;
18601   Dali::TypeInfo *result = 0 ;
18602
18603   arg1 = (Dali::TypeInfo *)jarg1;
18604   arg2 = (Dali::TypeInfo *)jarg2;
18605   if (!arg2) {
18606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18607     return 0;
18608   }
18609   {
18610     try {
18611       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18612     } catch (std::out_of_range& e) {
18613       {
18614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18615       };
18616     } catch (std::exception& e) {
18617       {
18618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18619       };
18620     } catch (...) {
18621       {
18622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18623       };
18624     }
18625   }
18626   jresult = (void *)result;
18627   return jresult;
18628 }
18629
18630
18631 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18632   char * jresult ;
18633   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18634   std::string *result = 0 ;
18635
18636   arg1 = (Dali::TypeInfo *)jarg1;
18637   {
18638     try {
18639       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18640     } catch (std::out_of_range& e) {
18641       {
18642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18643       };
18644     } catch (std::exception& e) {
18645       {
18646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18647       };
18648     } catch (...) {
18649       {
18650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18651       };
18652     }
18653   }
18654   jresult = SWIG_csharp_string_callback(result->c_str());
18655   return jresult;
18656 }
18657
18658
18659 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18660   char * jresult ;
18661   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18662   std::string *result = 0 ;
18663
18664   arg1 = (Dali::TypeInfo *)jarg1;
18665   {
18666     try {
18667       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18668     } catch (std::out_of_range& e) {
18669       {
18670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18671       };
18672     } catch (std::exception& e) {
18673       {
18674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18675       };
18676     } catch (...) {
18677       {
18678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18679       };
18680     }
18681   }
18682   jresult = SWIG_csharp_string_callback(result->c_str());
18683   return jresult;
18684 }
18685
18686
18687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18688   void * jresult ;
18689   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18690   Dali::BaseHandle result;
18691
18692   arg1 = (Dali::TypeInfo *)jarg1;
18693   {
18694     try {
18695       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18696     } catch (std::out_of_range& e) {
18697       {
18698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18699       };
18700     } catch (std::exception& e) {
18701       {
18702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18703       };
18704     } catch (...) {
18705       {
18706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18707       };
18708     }
18709   }
18710   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18711   return jresult;
18712 }
18713
18714
18715 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18716   unsigned long jresult ;
18717   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18718   size_t result;
18719
18720   arg1 = (Dali::TypeInfo *)jarg1;
18721   {
18722     try {
18723       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18724     } catch (std::out_of_range& e) {
18725       {
18726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18727       };
18728     } catch (std::exception& e) {
18729       {
18730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18731       };
18732     } catch (...) {
18733       {
18734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18735       };
18736     }
18737   }
18738   jresult = (unsigned long)result;
18739   return jresult;
18740 }
18741
18742
18743 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18744   char * jresult ;
18745   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18746   size_t arg2 ;
18747   std::string result;
18748
18749   arg1 = (Dali::TypeInfo *)jarg1;
18750   arg2 = (size_t)jarg2;
18751   {
18752     try {
18753       result = (arg1)->GetActionName(arg2);
18754     } catch (std::out_of_range& e) {
18755       {
18756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18757       };
18758     } catch (std::exception& e) {
18759       {
18760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18761       };
18762     } catch (...) {
18763       {
18764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18765       };
18766     }
18767   }
18768   jresult = SWIG_csharp_string_callback((&result)->c_str());
18769   return jresult;
18770 }
18771
18772
18773 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18774   unsigned long jresult ;
18775   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18776   size_t result;
18777
18778   arg1 = (Dali::TypeInfo *)jarg1;
18779   {
18780     try {
18781       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18782     } catch (std::out_of_range& e) {
18783       {
18784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18785       };
18786     } catch (std::exception& e) {
18787       {
18788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18789       };
18790     } catch (...) {
18791       {
18792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18793       };
18794     }
18795   }
18796   jresult = (unsigned long)result;
18797   return jresult;
18798 }
18799
18800
18801 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18802   char * jresult ;
18803   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18804   size_t arg2 ;
18805   std::string result;
18806
18807   arg1 = (Dali::TypeInfo *)jarg1;
18808   arg2 = (size_t)jarg2;
18809   {
18810     try {
18811       result = (arg1)->GetSignalName(arg2);
18812     } catch (std::out_of_range& e) {
18813       {
18814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18815       };
18816     } catch (std::exception& e) {
18817       {
18818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18819       };
18820     } catch (...) {
18821       {
18822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18823       };
18824     }
18825   }
18826   jresult = SWIG_csharp_string_callback((&result)->c_str());
18827   return jresult;
18828 }
18829
18830
18831 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18832   unsigned long jresult ;
18833   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18834   size_t result;
18835
18836   arg1 = (Dali::TypeInfo *)jarg1;
18837   {
18838     try {
18839       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18840     } catch (std::out_of_range& e) {
18841       {
18842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18843       };
18844     } catch (std::exception& e) {
18845       {
18846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18847       };
18848     } catch (...) {
18849       {
18850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18851       };
18852     }
18853   }
18854   jresult = (unsigned long)result;
18855   return jresult;
18856 }
18857
18858
18859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18860   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18861   Dali::Property::IndexContainer *arg2 = 0 ;
18862
18863   arg1 = (Dali::TypeInfo *)jarg1;
18864   arg2 = (Dali::Property::IndexContainer *)jarg2;
18865   if (!arg2) {
18866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18867     return ;
18868   }
18869   {
18870     try {
18871       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18872     } catch (std::out_of_range& e) {
18873       {
18874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18875       };
18876     } catch (std::exception& e) {
18877       {
18878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18879       };
18880     } catch (...) {
18881       {
18882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18883       };
18884     }
18885   }
18886 }
18887
18888
18889 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18890   char * jresult ;
18891   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18892   Dali::Property::Index arg2 ;
18893   std::string *result = 0 ;
18894
18895   arg1 = (Dali::TypeInfo *)jarg1;
18896   arg2 = (Dali::Property::Index)jarg2;
18897   {
18898     try {
18899       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18900     } catch (std::out_of_range& e) {
18901       {
18902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18903       };
18904     } catch (std::exception& e) {
18905       {
18906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18907       };
18908     } catch (...) {
18909       {
18910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18911       };
18912     }
18913   }
18914   jresult = SWIG_csharp_string_callback(result->c_str());
18915   return jresult;
18916 }
18917
18918
18919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18920   void * jresult ;
18921   Dali::TypeRegistry result;
18922
18923   {
18924     try {
18925       result = Dali::TypeRegistry::Get();
18926     } catch (std::out_of_range& e) {
18927       {
18928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18929       };
18930     } catch (std::exception& e) {
18931       {
18932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18933       };
18934     } catch (...) {
18935       {
18936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18937       };
18938     }
18939   }
18940   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18941   return jresult;
18942 }
18943
18944
18945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18946   void * jresult ;
18947   Dali::TypeRegistry *result = 0 ;
18948
18949   {
18950     try {
18951       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18952     } catch (std::out_of_range& e) {
18953       {
18954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18955       };
18956     } catch (std::exception& e) {
18957       {
18958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18959       };
18960     } catch (...) {
18961       {
18962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18963       };
18964     }
18965   }
18966   jresult = (void *)result;
18967   return jresult;
18968 }
18969
18970
18971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
18972   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
18973
18974   arg1 = (Dali::TypeRegistry *)jarg1;
18975   {
18976     try {
18977       delete arg1;
18978     } catch (std::out_of_range& e) {
18979       {
18980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18981       };
18982     } catch (std::exception& e) {
18983       {
18984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18985       };
18986     } catch (...) {
18987       {
18988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18989       };
18990     }
18991   }
18992 }
18993
18994
18995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
18996   void * jresult ;
18997   Dali::TypeRegistry *arg1 = 0 ;
18998   Dali::TypeRegistry *result = 0 ;
18999
19000   arg1 = (Dali::TypeRegistry *)jarg1;
19001   if (!arg1) {
19002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19003     return 0;
19004   }
19005   {
19006     try {
19007       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19008     } catch (std::out_of_range& e) {
19009       {
19010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19011       };
19012     } catch (std::exception& e) {
19013       {
19014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19015       };
19016     } catch (...) {
19017       {
19018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19019       };
19020     }
19021   }
19022   jresult = (void *)result;
19023   return jresult;
19024 }
19025
19026
19027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19028   void * jresult ;
19029   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19030   Dali::TypeRegistry *arg2 = 0 ;
19031   Dali::TypeRegistry *result = 0 ;
19032
19033   arg1 = (Dali::TypeRegistry *)jarg1;
19034   arg2 = (Dali::TypeRegistry *)jarg2;
19035   if (!arg2) {
19036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19037     return 0;
19038   }
19039   {
19040     try {
19041       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19042     } catch (std::out_of_range& e) {
19043       {
19044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19045       };
19046     } catch (std::exception& e) {
19047       {
19048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19049       };
19050     } catch (...) {
19051       {
19052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19053       };
19054     }
19055   }
19056   jresult = (void *)result;
19057   return jresult;
19058 }
19059
19060
19061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19062   void * jresult ;
19063   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19064   std::string *arg2 = 0 ;
19065   Dali::TypeInfo result;
19066
19067   arg1 = (Dali::TypeRegistry *)jarg1;
19068   if (!jarg2) {
19069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19070     return 0;
19071   }
19072   std::string arg2_str(jarg2);
19073   arg2 = &arg2_str;
19074   {
19075     try {
19076       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19077     } catch (std::out_of_range& e) {
19078       {
19079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19080       };
19081     } catch (std::exception& e) {
19082       {
19083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19084       };
19085     } catch (...) {
19086       {
19087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19088       };
19089     }
19090   }
19091   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19092
19093   //argout typemap for const std::string&
19094
19095   return jresult;
19096 }
19097
19098
19099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19100   void * jresult ;
19101   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19102   std::type_info *arg2 = 0 ;
19103   Dali::TypeInfo result;
19104
19105   arg1 = (Dali::TypeRegistry *)jarg1;
19106   arg2 = (std::type_info *)jarg2;
19107   if (!arg2) {
19108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19109     return 0;
19110   }
19111   {
19112     try {
19113       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19114     } catch (std::out_of_range& e) {
19115       {
19116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19117       };
19118     } catch (std::exception& e) {
19119       {
19120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19121       };
19122     } catch (...) {
19123       {
19124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19125       };
19126     }
19127   }
19128   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19129   return jresult;
19130 }
19131
19132
19133 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19134   unsigned long jresult ;
19135   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19136   size_t result;
19137
19138   arg1 = (Dali::TypeRegistry *)jarg1;
19139   {
19140     try {
19141       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19142     } catch (std::out_of_range& e) {
19143       {
19144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19145       };
19146     } catch (std::exception& e) {
19147       {
19148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19149       };
19150     } catch (...) {
19151       {
19152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19153       };
19154     }
19155   }
19156   jresult = (unsigned long)result;
19157   return jresult;
19158 }
19159
19160
19161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19162   char * jresult ;
19163   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19164   size_t arg2 ;
19165   std::string result;
19166
19167   arg1 = (Dali::TypeRegistry *)jarg1;
19168   arg2 = (size_t)jarg2;
19169   {
19170     try {
19171       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19172     } catch (std::out_of_range& e) {
19173       {
19174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19175       };
19176     } catch (std::exception& e) {
19177       {
19178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19179       };
19180     } catch (...) {
19181       {
19182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19183       };
19184     }
19185   }
19186   jresult = SWIG_csharp_string_callback((&result)->c_str());
19187   return jresult;
19188 }
19189
19190
19191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19192   void * jresult ;
19193   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19194   Dali::TypeRegistry *result = 0 ;
19195
19196   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19197   {
19198     try {
19199       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19200     } catch (std::out_of_range& e) {
19201       {
19202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19203       };
19204     } catch (std::exception& e) {
19205       {
19206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19207       };
19208     } catch (...) {
19209       {
19210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19211       };
19212     }
19213   }
19214   jresult = (void *)result;
19215   return jresult;
19216 }
19217
19218
19219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19220   void * jresult ;
19221   std::type_info *arg1 = 0 ;
19222   std::type_info *arg2 = 0 ;
19223   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19224   Dali::TypeRegistration *result = 0 ;
19225
19226   arg1 = (std::type_info *)jarg1;
19227   if (!arg1) {
19228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19229     return 0;
19230   }
19231   arg2 = (std::type_info *)jarg2;
19232   if (!arg2) {
19233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19234     return 0;
19235   }
19236   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19237   {
19238     try {
19239       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19240     } catch (std::out_of_range& e) {
19241       {
19242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19243       };
19244     } catch (std::exception& e) {
19245       {
19246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19247       };
19248     } catch (...) {
19249       {
19250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19251       };
19252     }
19253   }
19254   jresult = (void *)result;
19255   return jresult;
19256 }
19257
19258
19259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19260   void * jresult ;
19261   std::type_info *arg1 = 0 ;
19262   std::type_info *arg2 = 0 ;
19263   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19264   bool arg4 ;
19265   Dali::TypeRegistration *result = 0 ;
19266
19267   arg1 = (std::type_info *)jarg1;
19268   if (!arg1) {
19269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19270     return 0;
19271   }
19272   arg2 = (std::type_info *)jarg2;
19273   if (!arg2) {
19274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19275     return 0;
19276   }
19277   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19278   arg4 = jarg4 ? true : false;
19279   {
19280     try {
19281       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19282     } catch (std::out_of_range& e) {
19283       {
19284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19285       };
19286     } catch (std::exception& e) {
19287       {
19288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19289       };
19290     } catch (...) {
19291       {
19292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19293       };
19294     }
19295   }
19296   jresult = (void *)result;
19297   return jresult;
19298 }
19299
19300
19301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19302   void * jresult ;
19303   std::string *arg1 = 0 ;
19304   std::type_info *arg2 = 0 ;
19305   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19306   Dali::TypeRegistration *result = 0 ;
19307
19308   if (!jarg1) {
19309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19310     return 0;
19311   }
19312   std::string arg1_str(jarg1);
19313   arg1 = &arg1_str;
19314   arg2 = (std::type_info *)jarg2;
19315   if (!arg2) {
19316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19317     return 0;
19318   }
19319   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19320   {
19321     try {
19322       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19323     } catch (std::out_of_range& e) {
19324       {
19325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19326       };
19327     } catch (std::exception& e) {
19328       {
19329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19330       };
19331     } catch (...) {
19332       {
19333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19334       };
19335     }
19336   }
19337   jresult = (void *)result;
19338
19339   //argout typemap for const std::string&
19340
19341   return jresult;
19342 }
19343
19344
19345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19346   char * jresult ;
19347   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19348   std::string result;
19349
19350   arg1 = (Dali::TypeRegistration *)jarg1;
19351   {
19352     try {
19353       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19354     } catch (std::out_of_range& e) {
19355       {
19356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19357       };
19358     } catch (std::exception& e) {
19359       {
19360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19361       };
19362     } catch (...) {
19363       {
19364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19365       };
19366     }
19367   }
19368   jresult = SWIG_csharp_string_callback((&result)->c_str());
19369   return jresult;
19370 }
19371
19372
19373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19374   std::string *arg1 = 0 ;
19375   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19376
19377   if (!jarg1) {
19378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19379     return ;
19380   }
19381   std::string arg1_str(jarg1);
19382   arg1 = &arg1_str;
19383   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19384   {
19385     try {
19386       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19387     } catch (std::out_of_range& e) {
19388       {
19389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19390       };
19391     } catch (std::exception& e) {
19392       {
19393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19394       };
19395     } catch (...) {
19396       {
19397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19398       };
19399     }
19400   }
19401
19402   //argout typemap for const std::string&
19403
19404 }
19405
19406
19407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19408   std::string *arg1 = 0 ;
19409   std::string *arg2 = 0 ;
19410   int arg3 ;
19411   Dali::Property::Type arg4 ;
19412   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19413   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19414
19415   if (!jarg1) {
19416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19417     return ;
19418   }
19419   std::string arg1_str(jarg1);
19420   arg1 = &arg1_str;
19421   if (!jarg2) {
19422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19423     return ;
19424   }
19425   std::string arg2_str(jarg2);
19426   arg2 = &arg2_str;
19427   arg3 = (int)jarg3;
19428   arg4 = (Dali::Property::Type)jarg4;
19429   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19430   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19431   {
19432     try {
19433       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19434     } catch (std::out_of_range& e) {
19435       {
19436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19437       };
19438     } catch (std::exception& e) {
19439       {
19440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19441       };
19442     } catch (...) {
19443       {
19444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19445       };
19446     }
19447   }
19448
19449   //argout typemap for const std::string&
19450
19451
19452   //argout typemap for const std::string&
19453
19454 }
19455
19456
19457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19458   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19459
19460   arg1 = (Dali::TypeRegistration *)jarg1;
19461   {
19462     try {
19463       delete arg1;
19464     } catch (std::out_of_range& e) {
19465       {
19466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19467       };
19468     } catch (std::exception& e) {
19469       {
19470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19471       };
19472     } catch (...) {
19473       {
19474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19475       };
19476     }
19477   }
19478 }
19479
19480
19481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19482   void * jresult ;
19483   Dali::TypeRegistration *arg1 = 0 ;
19484   std::string *arg2 = 0 ;
19485   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19486   Dali::SignalConnectorType *result = 0 ;
19487
19488   arg1 = (Dali::TypeRegistration *)jarg1;
19489   if (!arg1) {
19490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19491     return 0;
19492   }
19493   if (!jarg2) {
19494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19495     return 0;
19496   }
19497   std::string arg2_str(jarg2);
19498   arg2 = &arg2_str;
19499   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19500   {
19501     try {
19502       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19503     } catch (std::out_of_range& e) {
19504       {
19505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19506       };
19507     } catch (std::exception& e) {
19508       {
19509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19510       };
19511     } catch (...) {
19512       {
19513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19514       };
19515     }
19516   }
19517   jresult = (void *)result;
19518
19519   //argout typemap for const std::string&
19520
19521   return jresult;
19522 }
19523
19524
19525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19526   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19527
19528   arg1 = (Dali::SignalConnectorType *)jarg1;
19529   {
19530     try {
19531       delete arg1;
19532     } catch (std::out_of_range& e) {
19533       {
19534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19535       };
19536     } catch (std::exception& e) {
19537       {
19538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19539       };
19540     } catch (...) {
19541       {
19542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19543       };
19544     }
19545   }
19546 }
19547
19548
19549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19550   void * jresult ;
19551   Dali::TypeRegistration *arg1 = 0 ;
19552   std::string *arg2 = 0 ;
19553   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19554   Dali::TypeAction *result = 0 ;
19555
19556   arg1 = (Dali::TypeRegistration *)jarg1;
19557   if (!arg1) {
19558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19559     return 0;
19560   }
19561   if (!jarg2) {
19562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19563     return 0;
19564   }
19565   std::string arg2_str(jarg2);
19566   arg2 = &arg2_str;
19567   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19568   {
19569     try {
19570       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19571     } catch (std::out_of_range& e) {
19572       {
19573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19574       };
19575     } catch (std::exception& e) {
19576       {
19577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19578       };
19579     } catch (...) {
19580       {
19581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19582       };
19583     }
19584   }
19585   jresult = (void *)result;
19586
19587   //argout typemap for const std::string&
19588
19589   return jresult;
19590 }
19591
19592
19593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19594   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19595
19596   arg1 = (Dali::TypeAction *)jarg1;
19597   {
19598     try {
19599       delete arg1;
19600     } catch (std::out_of_range& e) {
19601       {
19602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19603       };
19604     } catch (std::exception& e) {
19605       {
19606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19607       };
19608     } catch (...) {
19609       {
19610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19611       };
19612     }
19613   }
19614 }
19615
19616
19617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19618   void * jresult ;
19619   Dali::TypeRegistration *arg1 = 0 ;
19620   std::string *arg2 = 0 ;
19621   Dali::Property::Index arg3 ;
19622   Dali::Property::Type arg4 ;
19623   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19624   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19625   Dali::PropertyRegistration *result = 0 ;
19626
19627   arg1 = (Dali::TypeRegistration *)jarg1;
19628   if (!arg1) {
19629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19630     return 0;
19631   }
19632   if (!jarg2) {
19633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19634     return 0;
19635   }
19636   std::string arg2_str(jarg2);
19637   arg2 = &arg2_str;
19638   arg3 = (Dali::Property::Index)jarg3;
19639   arg4 = (Dali::Property::Type)jarg4;
19640   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19641   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19642   {
19643     try {
19644       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19645     } catch (std::out_of_range& e) {
19646       {
19647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19648       };
19649     } catch (std::exception& e) {
19650       {
19651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19652       };
19653     } catch (...) {
19654       {
19655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19656       };
19657     }
19658   }
19659   jresult = (void *)result;
19660
19661   //argout typemap for const std::string&
19662
19663   return jresult;
19664 }
19665
19666
19667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19668   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19669
19670   arg1 = (Dali::PropertyRegistration *)jarg1;
19671   {
19672     try {
19673       delete arg1;
19674     } catch (std::out_of_range& e) {
19675       {
19676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19677       };
19678     } catch (std::exception& e) {
19679       {
19680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19681       };
19682     } catch (...) {
19683       {
19684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19685       };
19686     }
19687   }
19688 }
19689
19690
19691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19692   void * jresult ;
19693   Dali::TypeRegistration *arg1 = 0 ;
19694   std::string *arg2 = 0 ;
19695   Dali::Property::Index arg3 ;
19696   Dali::Property::Type arg4 ;
19697   Dali::AnimatablePropertyRegistration *result = 0 ;
19698
19699   arg1 = (Dali::TypeRegistration *)jarg1;
19700   if (!arg1) {
19701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19702     return 0;
19703   }
19704   if (!jarg2) {
19705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19706     return 0;
19707   }
19708   std::string arg2_str(jarg2);
19709   arg2 = &arg2_str;
19710   arg3 = (Dali::Property::Index)jarg3;
19711   arg4 = (Dali::Property::Type)jarg4;
19712   {
19713     try {
19714       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19715     } catch (std::out_of_range& e) {
19716       {
19717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19718       };
19719     } catch (std::exception& e) {
19720       {
19721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19722       };
19723     } catch (...) {
19724       {
19725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19726       };
19727     }
19728   }
19729   jresult = (void *)result;
19730
19731   //argout typemap for const std::string&
19732
19733   return jresult;
19734 }
19735
19736
19737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19738   void * jresult ;
19739   Dali::TypeRegistration *arg1 = 0 ;
19740   std::string *arg2 = 0 ;
19741   Dali::Property::Index arg3 ;
19742   Dali::Property::Value *arg4 = 0 ;
19743   Dali::AnimatablePropertyRegistration *result = 0 ;
19744
19745   arg1 = (Dali::TypeRegistration *)jarg1;
19746   if (!arg1) {
19747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19748     return 0;
19749   }
19750   if (!jarg2) {
19751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19752     return 0;
19753   }
19754   std::string arg2_str(jarg2);
19755   arg2 = &arg2_str;
19756   arg3 = (Dali::Property::Index)jarg3;
19757   arg4 = (Dali::Property::Value *)jarg4;
19758   if (!arg4) {
19759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19760     return 0;
19761   }
19762   {
19763     try {
19764       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19765     } catch (std::out_of_range& e) {
19766       {
19767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19768       };
19769     } catch (std::exception& e) {
19770       {
19771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19772       };
19773     } catch (...) {
19774       {
19775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19776       };
19777     }
19778   }
19779   jresult = (void *)result;
19780
19781   //argout typemap for const std::string&
19782
19783   return jresult;
19784 }
19785
19786
19787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19788   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19789
19790   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19791   {
19792     try {
19793       delete arg1;
19794     } catch (std::out_of_range& e) {
19795       {
19796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19797       };
19798     } catch (std::exception& e) {
19799       {
19800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19801       };
19802     } catch (...) {
19803       {
19804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19805       };
19806     }
19807   }
19808 }
19809
19810
19811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19812   void * jresult ;
19813   Dali::TypeRegistration *arg1 = 0 ;
19814   std::string *arg2 = 0 ;
19815   Dali::Property::Index arg3 ;
19816   Dali::Property::Index arg4 ;
19817   unsigned int arg5 ;
19818   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19819
19820   arg1 = (Dali::TypeRegistration *)jarg1;
19821   if (!arg1) {
19822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19823     return 0;
19824   }
19825   if (!jarg2) {
19826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19827     return 0;
19828   }
19829   std::string arg2_str(jarg2);
19830   arg2 = &arg2_str;
19831   arg3 = (Dali::Property::Index)jarg3;
19832   arg4 = (Dali::Property::Index)jarg4;
19833   arg5 = (unsigned int)jarg5;
19834   {
19835     try {
19836       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19837     } catch (std::out_of_range& e) {
19838       {
19839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19840       };
19841     } catch (std::exception& e) {
19842       {
19843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19844       };
19845     } catch (...) {
19846       {
19847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19848       };
19849     }
19850   }
19851   jresult = (void *)result;
19852
19853   //argout typemap for const std::string&
19854
19855   return jresult;
19856 }
19857
19858
19859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19860   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19861
19862   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19863   {
19864     try {
19865       delete arg1;
19866     } catch (std::out_of_range& e) {
19867       {
19868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19869       };
19870     } catch (std::exception& e) {
19871       {
19872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19873       };
19874     } catch (...) {
19875       {
19876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19877       };
19878     }
19879   }
19880 }
19881
19882
19883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19884   void * jresult ;
19885   Dali::TypeRegistration *arg1 = 0 ;
19886   std::string *arg2 = 0 ;
19887   Dali::Property::Index arg3 ;
19888   Dali::Property::Type arg4 ;
19889   Dali::ChildPropertyRegistration *result = 0 ;
19890
19891   arg1 = (Dali::TypeRegistration *)jarg1;
19892   if (!arg1) {
19893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19894     return 0;
19895   }
19896   if (!jarg2) {
19897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19898     return 0;
19899   }
19900   std::string arg2_str(jarg2);
19901   arg2 = &arg2_str;
19902   arg3 = (Dali::Property::Index)jarg3;
19903   arg4 = (Dali::Property::Type)jarg4;
19904   {
19905     try {
19906       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19907     } catch (std::out_of_range& e) {
19908       {
19909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19910       };
19911     } catch (std::exception& e) {
19912       {
19913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19914       };
19915     } catch (...) {
19916       {
19917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19918       };
19919     }
19920   }
19921   jresult = (void *)result;
19922
19923   //argout typemap for const std::string&
19924
19925   return jresult;
19926 }
19927
19928
19929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19930   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19931
19932   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19933   {
19934     try {
19935       delete arg1;
19936     } catch (std::out_of_range& e) {
19937       {
19938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19939       };
19940     } catch (std::exception& e) {
19941       {
19942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19943       };
19944     } catch (...) {
19945       {
19946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19947       };
19948     }
19949   }
19950 }
19951
19952
19953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19954   unsigned int jresult ;
19955   std::string *arg1 = 0 ;
19956   std::type_info *arg2 = 0 ;
19957   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19958   bool result;
19959
19960   if (!jarg1) {
19961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19962     return 0;
19963   }
19964   std::string arg1_str(jarg1);
19965   arg1 = &arg1_str;
19966   arg2 = (std::type_info *)jarg2;
19967   if (!arg2) {
19968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19969     return 0;
19970   }
19971   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
19972   {
19973     try {
19974       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19975     } catch (std::out_of_range& e) {
19976       {
19977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19978       };
19979     } catch (std::exception& e) {
19980       {
19981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19982       };
19983     } catch (...) {
19984       {
19985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19986       };
19987     }
19988   }
19989   jresult = result;
19990
19991   //argout typemap for const std::string&
19992
19993   return jresult;
19994 }
19995
19996
19997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19998   unsigned int jresult ;
19999   std::string *arg1 = 0 ;
20000   std::string *arg2 = 0 ;
20001   Dali::Property::Index arg3 ;
20002   Dali::Property::Type arg4 ;
20003   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20004   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20005   bool result;
20006
20007   if (!jarg1) {
20008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20009     return 0;
20010   }
20011   std::string arg1_str(jarg1);
20012   arg1 = &arg1_str;
20013   if (!jarg2) {
20014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20015     return 0;
20016   }
20017   std::string arg2_str(jarg2);
20018   arg2 = &arg2_str;
20019   arg3 = (Dali::Property::Index)jarg3;
20020   arg4 = (Dali::Property::Type)jarg4;
20021   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20022   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20023   {
20024     try {
20025       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20026     } catch (std::out_of_range& e) {
20027       {
20028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20029       };
20030     } catch (std::exception& e) {
20031       {
20032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20033       };
20034     } catch (...) {
20035       {
20036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20037       };
20038     }
20039   }
20040   jresult = result;
20041
20042   //argout typemap for const std::string&
20043
20044
20045   //argout typemap for const std::string&
20046
20047   return jresult;
20048 }
20049
20050
20051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20052   float jresult ;
20053   float result;
20054
20055   result = (float)(float)Dali::ParentOrigin::TOP;
20056   jresult = result;
20057   return jresult;
20058 }
20059
20060
20061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20062   float jresult ;
20063   float result;
20064
20065   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20066   jresult = result;
20067   return jresult;
20068 }
20069
20070
20071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20072   float jresult ;
20073   float result;
20074
20075   result = (float)(float)Dali::ParentOrigin::LEFT;
20076   jresult = result;
20077   return jresult;
20078 }
20079
20080
20081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20082   float jresult ;
20083   float result;
20084
20085   result = (float)(float)Dali::ParentOrigin::RIGHT;
20086   jresult = result;
20087   return jresult;
20088 }
20089
20090
20091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20092   float jresult ;
20093   float result;
20094
20095   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20096   jresult = result;
20097   return jresult;
20098 }
20099
20100
20101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20102   void * jresult ;
20103   Dali::Vector3 *result = 0 ;
20104
20105   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20106   jresult = (void *)result;
20107   return jresult;
20108 }
20109
20110
20111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20112   void * jresult ;
20113   Dali::Vector3 *result = 0 ;
20114
20115   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20116   jresult = (void *)result;
20117   return jresult;
20118 }
20119
20120
20121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20122   void * jresult ;
20123   Dali::Vector3 *result = 0 ;
20124
20125   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20126   jresult = (void *)result;
20127   return jresult;
20128 }
20129
20130
20131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20132   void * jresult ;
20133   Dali::Vector3 *result = 0 ;
20134
20135   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20136   jresult = (void *)result;
20137   return jresult;
20138 }
20139
20140
20141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20142   void * jresult ;
20143   Dali::Vector3 *result = 0 ;
20144
20145   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20146   jresult = (void *)result;
20147   return jresult;
20148 }
20149
20150
20151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20152   void * jresult ;
20153   Dali::Vector3 *result = 0 ;
20154
20155   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20156   jresult = (void *)result;
20157   return jresult;
20158 }
20159
20160
20161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20162   void * jresult ;
20163   Dali::Vector3 *result = 0 ;
20164
20165   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20166   jresult = (void *)result;
20167   return jresult;
20168 }
20169
20170
20171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20172   void * jresult ;
20173   Dali::Vector3 *result = 0 ;
20174
20175   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20176   jresult = (void *)result;
20177   return jresult;
20178 }
20179
20180
20181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20182   void * jresult ;
20183   Dali::Vector3 *result = 0 ;
20184
20185   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20186   jresult = (void *)result;
20187   return jresult;
20188 }
20189
20190
20191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20192   float jresult ;
20193   float result;
20194
20195   result = (float)(float)Dali::AnchorPoint::TOP;
20196   jresult = result;
20197   return jresult;
20198 }
20199
20200
20201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20202   float jresult ;
20203   float result;
20204
20205   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20206   jresult = result;
20207   return jresult;
20208 }
20209
20210
20211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20212   float jresult ;
20213   float result;
20214
20215   result = (float)(float)Dali::AnchorPoint::LEFT;
20216   jresult = result;
20217   return jresult;
20218 }
20219
20220
20221 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20222   float jresult ;
20223   float result;
20224
20225   result = (float)(float)Dali::AnchorPoint::RIGHT;
20226   jresult = result;
20227   return jresult;
20228 }
20229
20230
20231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20232   float jresult ;
20233   float result;
20234
20235   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20236   jresult = result;
20237   return jresult;
20238 }
20239
20240
20241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20242   void * jresult ;
20243   Dali::Vector3 *result = 0 ;
20244
20245   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20246   jresult = (void *)result;
20247   return jresult;
20248 }
20249
20250
20251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20252   void * jresult ;
20253   Dali::Vector3 *result = 0 ;
20254
20255   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20256   jresult = (void *)result;
20257   return jresult;
20258 }
20259
20260
20261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20262   void * jresult ;
20263   Dali::Vector3 *result = 0 ;
20264
20265   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20266   jresult = (void *)result;
20267   return jresult;
20268 }
20269
20270
20271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20272   void * jresult ;
20273   Dali::Vector3 *result = 0 ;
20274
20275   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20276   jresult = (void *)result;
20277   return jresult;
20278 }
20279
20280
20281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20282   void * jresult ;
20283   Dali::Vector3 *result = 0 ;
20284
20285   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20286   jresult = (void *)result;
20287   return jresult;
20288 }
20289
20290
20291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20292   void * jresult ;
20293   Dali::Vector3 *result = 0 ;
20294
20295   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20296   jresult = (void *)result;
20297   return jresult;
20298 }
20299
20300
20301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20302   void * jresult ;
20303   Dali::Vector3 *result = 0 ;
20304
20305   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20306   jresult = (void *)result;
20307   return jresult;
20308 }
20309
20310
20311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20312   void * jresult ;
20313   Dali::Vector3 *result = 0 ;
20314
20315   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20316   jresult = (void *)result;
20317   return jresult;
20318 }
20319
20320
20321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20322   void * jresult ;
20323   Dali::Vector3 *result = 0 ;
20324
20325   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20326   jresult = (void *)result;
20327   return jresult;
20328 }
20329
20330
20331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20332   void * jresult ;
20333   Dali::Vector4 *result = 0 ;
20334
20335   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20336   jresult = (void *)result;
20337   return jresult;
20338 }
20339
20340
20341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20342   void * jresult ;
20343   Dali::Vector4 *result = 0 ;
20344
20345   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20346   jresult = (void *)result;
20347   return jresult;
20348 }
20349
20350
20351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20352   void * jresult ;
20353   Dali::Vector4 *result = 0 ;
20354
20355   result = (Dali::Vector4 *)&Dali::Color::RED;
20356   jresult = (void *)result;
20357   return jresult;
20358 }
20359
20360
20361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20362   void * jresult ;
20363   Dali::Vector4 *result = 0 ;
20364
20365   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20366   jresult = (void *)result;
20367   return jresult;
20368 }
20369
20370
20371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20372   void * jresult ;
20373   Dali::Vector4 *result = 0 ;
20374
20375   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20376   jresult = (void *)result;
20377   return jresult;
20378 }
20379
20380
20381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20382   void * jresult ;
20383   Dali::Vector4 *result = 0 ;
20384
20385   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20386   jresult = (void *)result;
20387   return jresult;
20388 }
20389
20390
20391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20392   void * jresult ;
20393   Dali::Vector4 *result = 0 ;
20394
20395   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20396   jresult = (void *)result;
20397   return jresult;
20398 }
20399
20400
20401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20402   void * jresult ;
20403   Dali::Vector4 *result = 0 ;
20404
20405   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20406   jresult = (void *)result;
20407   return jresult;
20408 }
20409
20410
20411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20412   void * jresult ;
20413   Dali::Vector4 *result = 0 ;
20414
20415   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20416   jresult = (void *)result;
20417   return jresult;
20418 }
20419
20420
20421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20422   float jresult ;
20423   float result;
20424
20425   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20426   jresult = result;
20427   return jresult;
20428 }
20429
20430
20431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20432   float jresult ;
20433   float result;
20434
20435   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20436   jresult = result;
20437   return jresult;
20438 }
20439
20440
20441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20442   float jresult ;
20443   float result;
20444
20445   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20446   jresult = result;
20447   return jresult;
20448 }
20449
20450
20451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20452   float jresult ;
20453   float result;
20454
20455   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20456   jresult = result;
20457   return jresult;
20458 }
20459
20460
20461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20462   float jresult ;
20463   float result;
20464
20465   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20466   jresult = result;
20467   return jresult;
20468 }
20469
20470
20471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20472   float jresult ;
20473   float result;
20474
20475   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20476   jresult = result;
20477   return jresult;
20478 }
20479
20480
20481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20482   float jresult ;
20483   float result;
20484
20485   result = (float)(float)Dali::Math::PI;
20486   jresult = result;
20487   return jresult;
20488 }
20489
20490
20491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20492   float jresult ;
20493   float result;
20494
20495   result = (float)(float)Dali::Math::PI_2;
20496   jresult = result;
20497   return jresult;
20498 }
20499
20500
20501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20502   float jresult ;
20503   float result;
20504
20505   result = (float)(float)Dali::Math::PI_4;
20506   jresult = result;
20507   return jresult;
20508 }
20509
20510
20511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20512   float jresult ;
20513   float result;
20514
20515   result = (float)(float)Dali::Math::PI_OVER_180;
20516   jresult = result;
20517   return jresult;
20518 }
20519
20520
20521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20522   float jresult ;
20523   float result;
20524
20525   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20526   jresult = result;
20527   return jresult;
20528 }
20529
20530
20531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20532   int jresult ;
20533   Dali::ResizePolicy::Type result;
20534
20535   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20536   jresult = (int)result;
20537   return jresult;
20538 }
20539
20540
20541 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20542   unsigned long jresult ;
20543   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20544   Dali::VectorBase::SizeType result;
20545
20546   arg1 = (Dali::VectorBase *)jarg1;
20547   {
20548     try {
20549       result = ((Dali::VectorBase const *)arg1)->Count();
20550     } catch (std::out_of_range& e) {
20551       {
20552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20553       };
20554     } catch (std::exception& e) {
20555       {
20556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20557       };
20558     } catch (...) {
20559       {
20560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20561       };
20562     }
20563   }
20564   jresult = (unsigned long)result;
20565   return jresult;
20566 }
20567
20568
20569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20570   unsigned long jresult ;
20571   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20572   Dali::VectorBase::SizeType result;
20573
20574   arg1 = (Dali::VectorBase *)jarg1;
20575   {
20576     try {
20577       result = ((Dali::VectorBase const *)arg1)->Size();
20578     } catch (std::out_of_range& e) {
20579       {
20580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20581       };
20582     } catch (std::exception& e) {
20583       {
20584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20585       };
20586     } catch (...) {
20587       {
20588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20589       };
20590     }
20591   }
20592   jresult = (unsigned long)result;
20593   return jresult;
20594 }
20595
20596
20597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20598   unsigned int jresult ;
20599   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20600   bool result;
20601
20602   arg1 = (Dali::VectorBase *)jarg1;
20603   {
20604     try {
20605       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20606     } catch (std::out_of_range& e) {
20607       {
20608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20609       };
20610     } catch (std::exception& e) {
20611       {
20612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20613       };
20614     } catch (...) {
20615       {
20616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20617       };
20618     }
20619   }
20620   jresult = result;
20621   return jresult;
20622 }
20623
20624
20625 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20626   unsigned long jresult ;
20627   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20628   Dali::VectorBase::SizeType result;
20629
20630   arg1 = (Dali::VectorBase *)jarg1;
20631   {
20632     try {
20633       result = ((Dali::VectorBase const *)arg1)->Capacity();
20634     } catch (std::out_of_range& e) {
20635       {
20636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20637       };
20638     } catch (std::exception& e) {
20639       {
20640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20641       };
20642     } catch (...) {
20643       {
20644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20645       };
20646     }
20647   }
20648   jresult = (unsigned long)result;
20649   return jresult;
20650 }
20651
20652
20653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20654   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20655
20656   arg1 = (Dali::VectorBase *)jarg1;
20657   {
20658     try {
20659       (arg1)->Release();
20660     } catch (std::out_of_range& e) {
20661       {
20662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20663       };
20664     } catch (std::exception& e) {
20665       {
20666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20667       };
20668     } catch (...) {
20669       {
20670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20671       };
20672     }
20673   }
20674 }
20675
20676
20677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20678   void * jresult ;
20679   Dali::Image *result = 0 ;
20680
20681   {
20682     try {
20683       result = (Dali::Image *)new Dali::Image();
20684     } catch (std::out_of_range& e) {
20685       {
20686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20687       };
20688     } catch (std::exception& e) {
20689       {
20690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20691       };
20692     } catch (...) {
20693       {
20694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20695       };
20696     }
20697   }
20698   jresult = (void *)result;
20699   return jresult;
20700 }
20701
20702
20703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20704   Dali::Image *arg1 = (Dali::Image *) 0 ;
20705
20706   arg1 = (Dali::Image *)jarg1;
20707   {
20708     try {
20709       delete arg1;
20710     } catch (std::out_of_range& e) {
20711       {
20712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20713       };
20714     } catch (std::exception& e) {
20715       {
20716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20717       };
20718     } catch (...) {
20719       {
20720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20721       };
20722     }
20723   }
20724 }
20725
20726
20727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20728   void * jresult ;
20729   Dali::Image *arg1 = 0 ;
20730   Dali::Image *result = 0 ;
20731
20732   arg1 = (Dali::Image *)jarg1;
20733   if (!arg1) {
20734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20735     return 0;
20736   }
20737   {
20738     try {
20739       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20740     } catch (std::out_of_range& e) {
20741       {
20742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20743       };
20744     } catch (std::exception& e) {
20745       {
20746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20747       };
20748     } catch (...) {
20749       {
20750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20751       };
20752     }
20753   }
20754   jresult = (void *)result;
20755   return jresult;
20756 }
20757
20758
20759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20760   void * jresult ;
20761   Dali::Image *arg1 = (Dali::Image *) 0 ;
20762   Dali::Image *arg2 = 0 ;
20763   Dali::Image *result = 0 ;
20764
20765   arg1 = (Dali::Image *)jarg1;
20766   arg2 = (Dali::Image *)jarg2;
20767   if (!arg2) {
20768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20769     return 0;
20770   }
20771   {
20772     try {
20773       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20774     } catch (std::out_of_range& e) {
20775       {
20776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20777       };
20778     } catch (std::exception& e) {
20779       {
20780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20781       };
20782     } catch (...) {
20783       {
20784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20785       };
20786     }
20787   }
20788   jresult = (void *)result;
20789   return jresult;
20790 }
20791
20792
20793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20794   void * jresult ;
20795   Dali::BaseHandle arg1 ;
20796   Dali::BaseHandle *argp1 ;
20797   Dali::Image result;
20798
20799   argp1 = (Dali::BaseHandle *)jarg1;
20800   if (!argp1) {
20801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20802     return 0;
20803   }
20804   arg1 = *argp1;
20805   {
20806     try {
20807       result = Dali::Image::DownCast(arg1);
20808     } catch (std::out_of_range& e) {
20809       {
20810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20811       };
20812     } catch (std::exception& e) {
20813       {
20814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20815       };
20816     } catch (...) {
20817       {
20818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20819       };
20820     }
20821   }
20822   jresult = new Dali::Image((const Dali::Image &)result);
20823   return jresult;
20824 }
20825
20826
20827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20828   unsigned int jresult ;
20829   Dali::Image *arg1 = (Dali::Image *) 0 ;
20830   unsigned int result;
20831
20832   arg1 = (Dali::Image *)jarg1;
20833   {
20834     try {
20835       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20836     } catch (std::out_of_range& e) {
20837       {
20838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20839       };
20840     } catch (std::exception& e) {
20841       {
20842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20843       };
20844     } catch (...) {
20845       {
20846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20847       };
20848     }
20849   }
20850   jresult = result;
20851   return jresult;
20852 }
20853
20854
20855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20856   unsigned int jresult ;
20857   Dali::Image *arg1 = (Dali::Image *) 0 ;
20858   unsigned int result;
20859
20860   arg1 = (Dali::Image *)jarg1;
20861   {
20862     try {
20863       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20864     } catch (std::out_of_range& e) {
20865       {
20866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20867       };
20868     } catch (std::exception& e) {
20869       {
20870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (...) {
20873       {
20874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20875       };
20876     }
20877   }
20878   jresult = result;
20879   return jresult;
20880 }
20881
20882
20883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20884   void * jresult ;
20885   Dali::Image *arg1 = (Dali::Image *) 0 ;
20886   Dali::Image::ImageSignalType *result = 0 ;
20887
20888   arg1 = (Dali::Image *)jarg1;
20889   {
20890     try {
20891       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20892     } catch (std::out_of_range& e) {
20893       {
20894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20895       };
20896     } catch (std::exception& e) {
20897       {
20898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20899       };
20900     } catch (...) {
20901       {
20902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20903       };
20904     }
20905   }
20906   jresult = (void *)result;
20907   return jresult;
20908 }
20909
20910
20911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20912   int jresult ;
20913   Dali::Pixel::Format result;
20914
20915   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20916   jresult = (int)result;
20917   return jresult;
20918 }
20919
20920
20921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20922   int jresult ;
20923   Dali::Pixel::Format result;
20924
20925   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20926   jresult = (int)result;
20927   return jresult;
20928 }
20929
20930
20931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20932   unsigned int jresult ;
20933   Dali::Pixel::Format arg1 ;
20934   bool result;
20935
20936   arg1 = (Dali::Pixel::Format)jarg1;
20937   {
20938     try {
20939       result = (bool)Dali::Pixel::HasAlpha(arg1);
20940     } catch (std::out_of_range& e) {
20941       {
20942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20943       };
20944     } catch (std::exception& e) {
20945       {
20946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20947       };
20948     } catch (...) {
20949       {
20950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20951       };
20952     }
20953   }
20954   jresult = result;
20955   return jresult;
20956 }
20957
20958
20959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20960   unsigned int jresult ;
20961   Dali::Pixel::Format arg1 ;
20962   unsigned int result;
20963
20964   arg1 = (Dali::Pixel::Format)jarg1;
20965   {
20966     try {
20967       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20968     } catch (std::out_of_range& e) {
20969       {
20970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20971       };
20972     } catch (std::exception& e) {
20973       {
20974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20975       };
20976     } catch (...) {
20977       {
20978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20979       };
20980     }
20981   }
20982   jresult = result;
20983   return jresult;
20984 }
20985
20986
20987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
20988   Dali::Pixel::Format arg1 ;
20989   int *arg2 = 0 ;
20990   int *arg3 = 0 ;
20991
20992   arg1 = (Dali::Pixel::Format)jarg1;
20993   arg2 = (int *)jarg2;
20994   if (!arg2) {
20995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
20996     return ;
20997   }
20998   arg3 = (int *)jarg3;
20999   if (!arg3) {
21000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21001     return ;
21002   }
21003   {
21004     try {
21005       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21006     } catch (std::out_of_range& e) {
21007       {
21008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21009       };
21010     } catch (std::exception& e) {
21011       {
21012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21013       };
21014     } catch (...) {
21015       {
21016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21017       };
21018     }
21019   }
21020 }
21021
21022
21023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21024   void * jresult ;
21025   unsigned char *arg1 = (unsigned char *) 0 ;
21026   unsigned int arg2 ;
21027   unsigned int arg3 ;
21028   unsigned int arg4 ;
21029   Dali::Pixel::Format arg5 ;
21030   Dali::PixelData::ReleaseFunction arg6 ;
21031   Dali::PixelData result;
21032
21033   arg1 = jarg1;
21034   arg2 = (unsigned int)jarg2;
21035   arg3 = (unsigned int)jarg3;
21036   arg4 = (unsigned int)jarg4;
21037   arg5 = (Dali::Pixel::Format)jarg5;
21038   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21039   {
21040     try {
21041       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21042     } catch (std::out_of_range& e) {
21043       {
21044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21045       };
21046     } catch (std::exception& e) {
21047       {
21048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21049       };
21050     } catch (...) {
21051       {
21052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21053       };
21054     }
21055   }
21056   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21057
21058
21059   return jresult;
21060 }
21061
21062
21063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21064   void * jresult ;
21065   Dali::PixelData *result = 0 ;
21066
21067   {
21068     try {
21069       result = (Dali::PixelData *)new Dali::PixelData();
21070     } catch (std::out_of_range& e) {
21071       {
21072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21073       };
21074     } catch (std::exception& e) {
21075       {
21076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21077       };
21078     } catch (...) {
21079       {
21080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21081       };
21082     }
21083   }
21084   jresult = (void *)result;
21085   return jresult;
21086 }
21087
21088
21089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21090   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21091
21092   arg1 = (Dali::PixelData *)jarg1;
21093   {
21094     try {
21095       delete arg1;
21096     } catch (std::out_of_range& e) {
21097       {
21098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21099       };
21100     } catch (std::exception& e) {
21101       {
21102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21103       };
21104     } catch (...) {
21105       {
21106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21107       };
21108     }
21109   }
21110 }
21111
21112
21113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21114   void * jresult ;
21115   Dali::PixelData *arg1 = 0 ;
21116   Dali::PixelData *result = 0 ;
21117
21118   arg1 = (Dali::PixelData *)jarg1;
21119   if (!arg1) {
21120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21121     return 0;
21122   }
21123   {
21124     try {
21125       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21126     } catch (std::out_of_range& e) {
21127       {
21128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21129       };
21130     } catch (std::exception& e) {
21131       {
21132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21133       };
21134     } catch (...) {
21135       {
21136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21137       };
21138     }
21139   }
21140   jresult = (void *)result;
21141   return jresult;
21142 }
21143
21144
21145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21146   void * jresult ;
21147   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21148   Dali::PixelData *arg2 = 0 ;
21149   Dali::PixelData *result = 0 ;
21150
21151   arg1 = (Dali::PixelData *)jarg1;
21152   arg2 = (Dali::PixelData *)jarg2;
21153   if (!arg2) {
21154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21155     return 0;
21156   }
21157   {
21158     try {
21159       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21160     } catch (std::out_of_range& e) {
21161       {
21162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21163       };
21164     } catch (std::exception& e) {
21165       {
21166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21167       };
21168     } catch (...) {
21169       {
21170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21171       };
21172     }
21173   }
21174   jresult = (void *)result;
21175   return jresult;
21176 }
21177
21178
21179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21180   unsigned int jresult ;
21181   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21182   unsigned int result;
21183
21184   arg1 = (Dali::PixelData *)jarg1;
21185   {
21186     try {
21187       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21188     } catch (std::out_of_range& e) {
21189       {
21190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21191       };
21192     } catch (std::exception& e) {
21193       {
21194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21195       };
21196     } catch (...) {
21197       {
21198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21199       };
21200     }
21201   }
21202   jresult = result;
21203   return jresult;
21204 }
21205
21206
21207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21208   unsigned int jresult ;
21209   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21210   unsigned int result;
21211
21212   arg1 = (Dali::PixelData *)jarg1;
21213   {
21214     try {
21215       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21216     } catch (std::out_of_range& e) {
21217       {
21218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21219       };
21220     } catch (std::exception& e) {
21221       {
21222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21223       };
21224     } catch (...) {
21225       {
21226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21227       };
21228     }
21229   }
21230   jresult = result;
21231   return jresult;
21232 }
21233
21234
21235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21236   int jresult ;
21237   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21238   Dali::Pixel::Format result;
21239
21240   arg1 = (Dali::PixelData *)jarg1;
21241   {
21242     try {
21243       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21244     } catch (std::out_of_range& e) {
21245       {
21246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21247       };
21248     } catch (std::exception& e) {
21249       {
21250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21251       };
21252     } catch (...) {
21253       {
21254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21255       };
21256     }
21257   }
21258   jresult = (int)result;
21259   return jresult;
21260 }
21261
21262
21263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21264   unsigned int jresult ;
21265   unsigned int result;
21266
21267   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21268   jresult = result;
21269   return jresult;
21270 }
21271
21272
21273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21274   unsigned int jresult ;
21275   unsigned int result;
21276
21277   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21278   jresult = result;
21279   return jresult;
21280 }
21281
21282
21283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21284   unsigned int jresult ;
21285   unsigned int result;
21286
21287   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21288   jresult = result;
21289   return jresult;
21290 }
21291
21292
21293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21294   unsigned int jresult ;
21295   unsigned int result;
21296
21297   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21298   jresult = result;
21299   return jresult;
21300 }
21301
21302
21303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21304   unsigned int jresult ;
21305   unsigned int result;
21306
21307   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21308   jresult = result;
21309   return jresult;
21310 }
21311
21312
21313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21314   unsigned int jresult ;
21315   unsigned int result;
21316
21317   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21318   jresult = result;
21319   return jresult;
21320 }
21321
21322
21323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21324   void * jresult ;
21325   Dali::TextureType::Type arg1 ;
21326   Dali::Pixel::Format arg2 ;
21327   unsigned int arg3 ;
21328   unsigned int arg4 ;
21329   Dali::Texture result;
21330
21331   arg1 = (Dali::TextureType::Type)jarg1;
21332   arg2 = (Dali::Pixel::Format)jarg2;
21333   arg3 = (unsigned int)jarg3;
21334   arg4 = (unsigned int)jarg4;
21335   {
21336     try {
21337       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21338     } catch (std::out_of_range& e) {
21339       {
21340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21341       };
21342     } catch (std::exception& e) {
21343       {
21344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21345       };
21346     } catch (...) {
21347       {
21348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21349       };
21350     }
21351   }
21352   jresult = new Dali::Texture((const Dali::Texture &)result);
21353   return jresult;
21354 }
21355
21356
21357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21358   void * jresult ;
21359   NativeImageInterface *arg1 = 0 ;
21360   Dali::Texture result;
21361
21362   arg1 = (NativeImageInterface *)jarg1;
21363   if (!arg1) {
21364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21365     return 0;
21366   }
21367   {
21368     try {
21369       result = Dali::Texture::New(*arg1);
21370     } catch (std::out_of_range& e) {
21371       {
21372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21373       };
21374     } catch (std::exception& e) {
21375       {
21376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21377       };
21378     } catch (...) {
21379       {
21380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21381       };
21382     }
21383   }
21384   jresult = new Dali::Texture((const Dali::Texture &)result);
21385   return jresult;
21386 }
21387
21388
21389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21390   void * jresult ;
21391   Dali::Texture *result = 0 ;
21392
21393   {
21394     try {
21395       result = (Dali::Texture *)new Dali::Texture();
21396     } catch (std::out_of_range& e) {
21397       {
21398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21399       };
21400     } catch (std::exception& e) {
21401       {
21402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21403       };
21404     } catch (...) {
21405       {
21406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21407       };
21408     }
21409   }
21410   jresult = (void *)result;
21411   return jresult;
21412 }
21413
21414
21415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21416   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21417
21418   arg1 = (Dali::Texture *)jarg1;
21419   {
21420     try {
21421       delete arg1;
21422     } catch (std::out_of_range& e) {
21423       {
21424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21425       };
21426     } catch (std::exception& e) {
21427       {
21428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21429       };
21430     } catch (...) {
21431       {
21432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21433       };
21434     }
21435   }
21436 }
21437
21438
21439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21440   void * jresult ;
21441   Dali::Texture *arg1 = 0 ;
21442   Dali::Texture *result = 0 ;
21443
21444   arg1 = (Dali::Texture *)jarg1;
21445   if (!arg1) {
21446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21447     return 0;
21448   }
21449   {
21450     try {
21451       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21452     } catch (std::out_of_range& e) {
21453       {
21454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21455       };
21456     } catch (std::exception& e) {
21457       {
21458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21459       };
21460     } catch (...) {
21461       {
21462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21463       };
21464     }
21465   }
21466   jresult = (void *)result;
21467   return jresult;
21468 }
21469
21470
21471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21472   void * jresult ;
21473   Dali::BaseHandle arg1 ;
21474   Dali::BaseHandle *argp1 ;
21475   Dali::Texture result;
21476
21477   argp1 = (Dali::BaseHandle *)jarg1;
21478   if (!argp1) {
21479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21480     return 0;
21481   }
21482   arg1 = *argp1;
21483   {
21484     try {
21485       result = Dali::Texture::DownCast(arg1);
21486     } catch (std::out_of_range& e) {
21487       {
21488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21489       };
21490     } catch (std::exception& e) {
21491       {
21492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21493       };
21494     } catch (...) {
21495       {
21496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21497       };
21498     }
21499   }
21500   jresult = new Dali::Texture((const Dali::Texture &)result);
21501   return jresult;
21502 }
21503
21504
21505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21506   void * jresult ;
21507   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21508   Dali::Texture *arg2 = 0 ;
21509   Dali::Texture *result = 0 ;
21510
21511   arg1 = (Dali::Texture *)jarg1;
21512   arg2 = (Dali::Texture *)jarg2;
21513   if (!arg2) {
21514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21515     return 0;
21516   }
21517   {
21518     try {
21519       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21520     } catch (std::out_of_range& e) {
21521       {
21522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21523       };
21524     } catch (std::exception& e) {
21525       {
21526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21527       };
21528     } catch (...) {
21529       {
21530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21531       };
21532     }
21533   }
21534   jresult = (void *)result;
21535   return jresult;
21536 }
21537
21538
21539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21540   unsigned int jresult ;
21541   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21542   Dali::PixelData arg2 ;
21543   Dali::PixelData *argp2 ;
21544   bool result;
21545
21546   arg1 = (Dali::Texture *)jarg1;
21547   argp2 = (Dali::PixelData *)jarg2;
21548   if (!argp2) {
21549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21550     return 0;
21551   }
21552   arg2 = *argp2;
21553   {
21554     try {
21555       result = (bool)(arg1)->Upload(arg2);
21556     } catch (std::out_of_range& e) {
21557       {
21558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21559       };
21560     } catch (std::exception& e) {
21561       {
21562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21563       };
21564     } catch (...) {
21565       {
21566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21567       };
21568     }
21569   }
21570   jresult = result;
21571   return jresult;
21572 }
21573
21574
21575 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) {
21576   unsigned int jresult ;
21577   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21578   Dali::PixelData arg2 ;
21579   unsigned int arg3 ;
21580   unsigned int arg4 ;
21581   unsigned int arg5 ;
21582   unsigned int arg6 ;
21583   unsigned int arg7 ;
21584   unsigned int arg8 ;
21585   Dali::PixelData *argp2 ;
21586   bool result;
21587
21588   arg1 = (Dali::Texture *)jarg1;
21589   argp2 = (Dali::PixelData *)jarg2;
21590   if (!argp2) {
21591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21592     return 0;
21593   }
21594   arg2 = *argp2;
21595   arg3 = (unsigned int)jarg3;
21596   arg4 = (unsigned int)jarg4;
21597   arg5 = (unsigned int)jarg5;
21598   arg6 = (unsigned int)jarg6;
21599   arg7 = (unsigned int)jarg7;
21600   arg8 = (unsigned int)jarg8;
21601   {
21602     try {
21603       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21604     } catch (std::out_of_range& e) {
21605       {
21606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21607       };
21608     } catch (std::exception& e) {
21609       {
21610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21611       };
21612     } catch (...) {
21613       {
21614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21615       };
21616     }
21617   }
21618   jresult = result;
21619   return jresult;
21620 }
21621
21622
21623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21624   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21625
21626   arg1 = (Dali::Texture *)jarg1;
21627   {
21628     try {
21629       (arg1)->GenerateMipmaps();
21630     } catch (std::out_of_range& e) {
21631       {
21632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21633       };
21634     } catch (std::exception& e) {
21635       {
21636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21637       };
21638     } catch (...) {
21639       {
21640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21641       };
21642     }
21643   }
21644 }
21645
21646
21647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21648   unsigned int jresult ;
21649   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21650   unsigned int result;
21651
21652   arg1 = (Dali::Texture *)jarg1;
21653   {
21654     try {
21655       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21656     } catch (std::out_of_range& e) {
21657       {
21658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21659       };
21660     } catch (std::exception& e) {
21661       {
21662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21663       };
21664     } catch (...) {
21665       {
21666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21667       };
21668     }
21669   }
21670   jresult = result;
21671   return jresult;
21672 }
21673
21674
21675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21676   unsigned int jresult ;
21677   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21678   unsigned int result;
21679
21680   arg1 = (Dali::Texture *)jarg1;
21681   {
21682     try {
21683       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21684     } catch (std::out_of_range& e) {
21685       {
21686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21687       };
21688     } catch (std::exception& e) {
21689       {
21690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21691       };
21692     } catch (...) {
21693       {
21694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21695       };
21696     }
21697   }
21698   jresult = result;
21699   return jresult;
21700 }
21701
21702
21703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21704   void * jresult ;
21705   Dali::Sampler result;
21706
21707   {
21708     try {
21709       result = Dali::Sampler::New();
21710     } catch (std::out_of_range& e) {
21711       {
21712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21713       };
21714     } catch (std::exception& e) {
21715       {
21716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21717       };
21718     } catch (...) {
21719       {
21720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21721       };
21722     }
21723   }
21724   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21725   return jresult;
21726 }
21727
21728
21729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21730   void * jresult ;
21731   Dali::Sampler *result = 0 ;
21732
21733   {
21734     try {
21735       result = (Dali::Sampler *)new Dali::Sampler();
21736     } catch (std::out_of_range& e) {
21737       {
21738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21739       };
21740     } catch (std::exception& e) {
21741       {
21742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21743       };
21744     } catch (...) {
21745       {
21746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21747       };
21748     }
21749   }
21750   jresult = (void *)result;
21751   return jresult;
21752 }
21753
21754
21755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21756   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21757
21758   arg1 = (Dali::Sampler *)jarg1;
21759   {
21760     try {
21761       delete arg1;
21762     } catch (std::out_of_range& e) {
21763       {
21764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21765       };
21766     } catch (std::exception& e) {
21767       {
21768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21769       };
21770     } catch (...) {
21771       {
21772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21773       };
21774     }
21775   }
21776 }
21777
21778
21779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21780   void * jresult ;
21781   Dali::Sampler *arg1 = 0 ;
21782   Dali::Sampler *result = 0 ;
21783
21784   arg1 = (Dali::Sampler *)jarg1;
21785   if (!arg1) {
21786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21787     return 0;
21788   }
21789   {
21790     try {
21791       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21792     } catch (std::out_of_range& e) {
21793       {
21794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21795       };
21796     } catch (std::exception& e) {
21797       {
21798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21799       };
21800     } catch (...) {
21801       {
21802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21803       };
21804     }
21805   }
21806   jresult = (void *)result;
21807   return jresult;
21808 }
21809
21810
21811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21812   void * jresult ;
21813   Dali::BaseHandle arg1 ;
21814   Dali::BaseHandle *argp1 ;
21815   Dali::Sampler result;
21816
21817   argp1 = (Dali::BaseHandle *)jarg1;
21818   if (!argp1) {
21819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21820     return 0;
21821   }
21822   arg1 = *argp1;
21823   {
21824     try {
21825       result = Dali::Sampler::DownCast(arg1);
21826     } catch (std::out_of_range& e) {
21827       {
21828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21829       };
21830     } catch (std::exception& e) {
21831       {
21832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21833       };
21834     } catch (...) {
21835       {
21836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21837       };
21838     }
21839   }
21840   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21841   return jresult;
21842 }
21843
21844
21845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21846   void * jresult ;
21847   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21848   Dali::Sampler *arg2 = 0 ;
21849   Dali::Sampler *result = 0 ;
21850
21851   arg1 = (Dali::Sampler *)jarg1;
21852   arg2 = (Dali::Sampler *)jarg2;
21853   if (!arg2) {
21854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21855     return 0;
21856   }
21857   {
21858     try {
21859       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21860     } catch (std::out_of_range& e) {
21861       {
21862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21863       };
21864     } catch (std::exception& e) {
21865       {
21866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21867       };
21868     } catch (...) {
21869       {
21870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21871       };
21872     }
21873   }
21874   jresult = (void *)result;
21875   return jresult;
21876 }
21877
21878
21879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21880   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21881   Dali::FilterMode::Type arg2 ;
21882   Dali::FilterMode::Type arg3 ;
21883
21884   arg1 = (Dali::Sampler *)jarg1;
21885   arg2 = (Dali::FilterMode::Type)jarg2;
21886   arg3 = (Dali::FilterMode::Type)jarg3;
21887   {
21888     try {
21889       (arg1)->SetFilterMode(arg2,arg3);
21890     } catch (std::out_of_range& e) {
21891       {
21892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21893       };
21894     } catch (std::exception& e) {
21895       {
21896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21897       };
21898     } catch (...) {
21899       {
21900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21901       };
21902     }
21903   }
21904 }
21905
21906
21907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21908   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21909   Dali::WrapMode::Type arg2 ;
21910   Dali::WrapMode::Type arg3 ;
21911
21912   arg1 = (Dali::Sampler *)jarg1;
21913   arg2 = (Dali::WrapMode::Type)jarg2;
21914   arg3 = (Dali::WrapMode::Type)jarg3;
21915   {
21916     try {
21917       (arg1)->SetWrapMode(arg2,arg3);
21918     } catch (std::out_of_range& e) {
21919       {
21920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21921       };
21922     } catch (std::exception& e) {
21923       {
21924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21925       };
21926     } catch (...) {
21927       {
21928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21929       };
21930     }
21931   }
21932 }
21933
21934
21935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21936   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21937   Dali::WrapMode::Type arg2 ;
21938   Dali::WrapMode::Type arg3 ;
21939   Dali::WrapMode::Type arg4 ;
21940
21941   arg1 = (Dali::Sampler *)jarg1;
21942   arg2 = (Dali::WrapMode::Type)jarg2;
21943   arg3 = (Dali::WrapMode::Type)jarg3;
21944   arg4 = (Dali::WrapMode::Type)jarg4;
21945   {
21946     try {
21947       (arg1)->SetWrapMode(arg2,arg3,arg4);
21948     } catch (std::out_of_range& e) {
21949       {
21950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21951       };
21952     } catch (std::exception& e) {
21953       {
21954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21955       };
21956     } catch (...) {
21957       {
21958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21959       };
21960     }
21961   }
21962 }
21963
21964
21965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
21966   void * jresult ;
21967   Dali::TextureSet result;
21968
21969   {
21970     try {
21971       result = Dali::TextureSet::New();
21972     } catch (std::out_of_range& e) {
21973       {
21974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21975       };
21976     } catch (std::exception& e) {
21977       {
21978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21979       };
21980     } catch (...) {
21981       {
21982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21983       };
21984     }
21985   }
21986   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
21987   return jresult;
21988 }
21989
21990
21991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
21992   void * jresult ;
21993   Dali::TextureSet *result = 0 ;
21994
21995   {
21996     try {
21997       result = (Dali::TextureSet *)new Dali::TextureSet();
21998     } catch (std::out_of_range& e) {
21999       {
22000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22001       };
22002     } catch (std::exception& e) {
22003       {
22004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22005       };
22006     } catch (...) {
22007       {
22008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22009       };
22010     }
22011   }
22012   jresult = (void *)result;
22013   return jresult;
22014 }
22015
22016
22017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22018   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22019
22020   arg1 = (Dali::TextureSet *)jarg1;
22021   {
22022     try {
22023       delete arg1;
22024     } catch (std::out_of_range& e) {
22025       {
22026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22027       };
22028     } catch (std::exception& e) {
22029       {
22030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22031       };
22032     } catch (...) {
22033       {
22034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22035       };
22036     }
22037   }
22038 }
22039
22040
22041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22042   void * jresult ;
22043   Dali::TextureSet *arg1 = 0 ;
22044   Dali::TextureSet *result = 0 ;
22045
22046   arg1 = (Dali::TextureSet *)jarg1;
22047   if (!arg1) {
22048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22049     return 0;
22050   }
22051   {
22052     try {
22053       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22054     } catch (std::out_of_range& e) {
22055       {
22056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22057       };
22058     } catch (std::exception& e) {
22059       {
22060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22061       };
22062     } catch (...) {
22063       {
22064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22065       };
22066     }
22067   }
22068   jresult = (void *)result;
22069   return jresult;
22070 }
22071
22072
22073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22074   void * jresult ;
22075   Dali::BaseHandle arg1 ;
22076   Dali::BaseHandle *argp1 ;
22077   Dali::TextureSet result;
22078
22079   argp1 = (Dali::BaseHandle *)jarg1;
22080   if (!argp1) {
22081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22082     return 0;
22083   }
22084   arg1 = *argp1;
22085   {
22086     try {
22087       result = Dali::TextureSet::DownCast(arg1);
22088     } catch (std::out_of_range& e) {
22089       {
22090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22091       };
22092     } catch (std::exception& e) {
22093       {
22094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22095       };
22096     } catch (...) {
22097       {
22098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22099       };
22100     }
22101   }
22102   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22103   return jresult;
22104 }
22105
22106
22107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22108   void * jresult ;
22109   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22110   Dali::TextureSet *arg2 = 0 ;
22111   Dali::TextureSet *result = 0 ;
22112
22113   arg1 = (Dali::TextureSet *)jarg1;
22114   arg2 = (Dali::TextureSet *)jarg2;
22115   if (!arg2) {
22116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22117     return 0;
22118   }
22119   {
22120     try {
22121       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22122     } catch (std::out_of_range& e) {
22123       {
22124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22125       };
22126     } catch (std::exception& e) {
22127       {
22128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22129       };
22130     } catch (...) {
22131       {
22132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22133       };
22134     }
22135   }
22136   jresult = (void *)result;
22137   return jresult;
22138 }
22139
22140
22141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22142   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22143   size_t arg2 ;
22144   Dali::Texture arg3 ;
22145   Dali::Texture *argp3 ;
22146
22147   arg1 = (Dali::TextureSet *)jarg1;
22148   arg2 = (size_t)jarg2;
22149   argp3 = (Dali::Texture *)jarg3;
22150   if (!argp3) {
22151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22152     return ;
22153   }
22154   arg3 = *argp3;
22155   {
22156     try {
22157       (arg1)->SetTexture(arg2,arg3);
22158     } catch (std::out_of_range& e) {
22159       {
22160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22161       };
22162     } catch (std::exception& e) {
22163       {
22164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22165       };
22166     } catch (...) {
22167       {
22168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22169       };
22170     }
22171   }
22172 }
22173
22174
22175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22176   void * jresult ;
22177   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22178   size_t arg2 ;
22179   Dali::Texture result;
22180
22181   arg1 = (Dali::TextureSet *)jarg1;
22182   arg2 = (size_t)jarg2;
22183   {
22184     try {
22185       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22186     } catch (std::out_of_range& e) {
22187       {
22188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22189       };
22190     } catch (std::exception& e) {
22191       {
22192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22193       };
22194     } catch (...) {
22195       {
22196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22197       };
22198     }
22199   }
22200   jresult = new Dali::Texture((const Dali::Texture &)result);
22201   return jresult;
22202 }
22203
22204
22205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22206   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22207   size_t arg2 ;
22208   Dali::Sampler arg3 ;
22209   Dali::Sampler *argp3 ;
22210
22211   arg1 = (Dali::TextureSet *)jarg1;
22212   arg2 = (size_t)jarg2;
22213   argp3 = (Dali::Sampler *)jarg3;
22214   if (!argp3) {
22215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22216     return ;
22217   }
22218   arg3 = *argp3;
22219   {
22220     try {
22221       (arg1)->SetSampler(arg2,arg3);
22222     } catch (std::out_of_range& e) {
22223       {
22224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22225       };
22226     } catch (std::exception& e) {
22227       {
22228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22229       };
22230     } catch (...) {
22231       {
22232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22233       };
22234     }
22235   }
22236 }
22237
22238
22239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22240   void * jresult ;
22241   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22242   size_t arg2 ;
22243   Dali::Sampler result;
22244
22245   arg1 = (Dali::TextureSet *)jarg1;
22246   arg2 = (size_t)jarg2;
22247   {
22248     try {
22249       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22250     } catch (std::out_of_range& e) {
22251       {
22252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22253       };
22254     } catch (std::exception& e) {
22255       {
22256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22257       };
22258     } catch (...) {
22259       {
22260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22261       };
22262     }
22263   }
22264   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22265   return jresult;
22266 }
22267
22268
22269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22270   unsigned long jresult ;
22271   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22272   size_t result;
22273
22274   arg1 = (Dali::TextureSet *)jarg1;
22275   {
22276     try {
22277       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22278     } catch (std::out_of_range& e) {
22279       {
22280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22281       };
22282     } catch (std::exception& e) {
22283       {
22284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22285       };
22286     } catch (...) {
22287       {
22288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22289       };
22290     }
22291   }
22292   jresult = (unsigned long)result;
22293   return jresult;
22294 }
22295
22296
22297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22298   void * jresult ;
22299   Dali::Property::Map *arg1 = 0 ;
22300   Dali::PropertyBuffer result;
22301
22302   arg1 = (Dali::Property::Map *)jarg1;
22303   if (!arg1) {
22304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22305     return 0;
22306   }
22307   {
22308     try {
22309       result = Dali::PropertyBuffer::New(*arg1);
22310     } catch (std::out_of_range& e) {
22311       {
22312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22313       };
22314     } catch (std::exception& e) {
22315       {
22316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22317       };
22318     } catch (...) {
22319       {
22320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22321       };
22322     }
22323   }
22324   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22325   return jresult;
22326 }
22327
22328
22329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22330   void * jresult ;
22331   Dali::PropertyBuffer *result = 0 ;
22332
22333   {
22334     try {
22335       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22336     } catch (std::out_of_range& e) {
22337       {
22338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22339       };
22340     } catch (std::exception& e) {
22341       {
22342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22343       };
22344     } catch (...) {
22345       {
22346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22347       };
22348     }
22349   }
22350   jresult = (void *)result;
22351   return jresult;
22352 }
22353
22354
22355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22356   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22357
22358   arg1 = (Dali::PropertyBuffer *)jarg1;
22359   {
22360     try {
22361       delete arg1;
22362     } catch (std::out_of_range& e) {
22363       {
22364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22365       };
22366     } catch (std::exception& e) {
22367       {
22368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22369       };
22370     } catch (...) {
22371       {
22372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22373       };
22374     }
22375   }
22376 }
22377
22378
22379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22380   void * jresult ;
22381   Dali::PropertyBuffer *arg1 = 0 ;
22382   Dali::PropertyBuffer *result = 0 ;
22383
22384   arg1 = (Dali::PropertyBuffer *)jarg1;
22385   if (!arg1) {
22386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22387     return 0;
22388   }
22389   {
22390     try {
22391       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22392     } catch (std::out_of_range& e) {
22393       {
22394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22395       };
22396     } catch (std::exception& e) {
22397       {
22398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22399       };
22400     } catch (...) {
22401       {
22402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22403       };
22404     }
22405   }
22406   jresult = (void *)result;
22407   return jresult;
22408 }
22409
22410
22411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22412   void * jresult ;
22413   Dali::BaseHandle arg1 ;
22414   Dali::BaseHandle *argp1 ;
22415   Dali::PropertyBuffer result;
22416
22417   argp1 = (Dali::BaseHandle *)jarg1;
22418   if (!argp1) {
22419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22420     return 0;
22421   }
22422   arg1 = *argp1;
22423   {
22424     try {
22425       result = Dali::PropertyBuffer::DownCast(arg1);
22426     } catch (std::out_of_range& e) {
22427       {
22428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22429       };
22430     } catch (std::exception& e) {
22431       {
22432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22433       };
22434     } catch (...) {
22435       {
22436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22437       };
22438     }
22439   }
22440   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22441   return jresult;
22442 }
22443
22444
22445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22446   void * jresult ;
22447   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22448   Dali::PropertyBuffer *arg2 = 0 ;
22449   Dali::PropertyBuffer *result = 0 ;
22450
22451   arg1 = (Dali::PropertyBuffer *)jarg1;
22452   arg2 = (Dali::PropertyBuffer *)jarg2;
22453   if (!arg2) {
22454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22455     return 0;
22456   }
22457   {
22458     try {
22459       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22460     } catch (std::out_of_range& e) {
22461       {
22462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22463       };
22464     } catch (std::exception& e) {
22465       {
22466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22467       };
22468     } catch (...) {
22469       {
22470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22471       };
22472     }
22473   }
22474   jresult = (void *)result;
22475   return jresult;
22476 }
22477
22478
22479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22480   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22481   void *arg2 = (void *) 0 ;
22482   std::size_t arg3 ;
22483
22484   arg1 = (Dali::PropertyBuffer *)jarg1;
22485   arg2 = jarg2;
22486   arg3 = (std::size_t)jarg3;
22487   {
22488     try {
22489       (arg1)->SetData((void const *)arg2,arg3);
22490     } catch (std::out_of_range& e) {
22491       {
22492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22493       };
22494     } catch (std::exception& e) {
22495       {
22496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22497       };
22498     } catch (...) {
22499       {
22500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22501       };
22502     }
22503   }
22504 }
22505
22506
22507 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22508   unsigned long jresult ;
22509   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22510   std::size_t result;
22511
22512   arg1 = (Dali::PropertyBuffer *)jarg1;
22513   {
22514     try {
22515       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22516     } catch (std::out_of_range& e) {
22517       {
22518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22519       };
22520     } catch (std::exception& e) {
22521       {
22522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22523       };
22524     } catch (...) {
22525       {
22526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22527       };
22528     }
22529   }
22530   jresult = (unsigned long)result;
22531   return jresult;
22532 }
22533
22534
22535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22536   void * jresult ;
22537   Dali::Geometry result;
22538
22539   {
22540     try {
22541       result = Dali::Geometry::New();
22542     } catch (std::out_of_range& e) {
22543       {
22544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22545       };
22546     } catch (std::exception& e) {
22547       {
22548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22549       };
22550     } catch (...) {
22551       {
22552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22553       };
22554     }
22555   }
22556   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22557   return jresult;
22558 }
22559
22560
22561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22562   void * jresult ;
22563   Dali::Geometry *result = 0 ;
22564
22565   {
22566     try {
22567       result = (Dali::Geometry *)new Dali::Geometry();
22568     } catch (std::out_of_range& e) {
22569       {
22570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22571       };
22572     } catch (std::exception& e) {
22573       {
22574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22575       };
22576     } catch (...) {
22577       {
22578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22579       };
22580     }
22581   }
22582   jresult = (void *)result;
22583   return jresult;
22584 }
22585
22586
22587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22588   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22589
22590   arg1 = (Dali::Geometry *)jarg1;
22591   {
22592     try {
22593       delete arg1;
22594     } catch (std::out_of_range& e) {
22595       {
22596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22597       };
22598     } catch (std::exception& e) {
22599       {
22600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22601       };
22602     } catch (...) {
22603       {
22604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22605       };
22606     }
22607   }
22608 }
22609
22610
22611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22612   void * jresult ;
22613   Dali::Geometry *arg1 = 0 ;
22614   Dali::Geometry *result = 0 ;
22615
22616   arg1 = (Dali::Geometry *)jarg1;
22617   if (!arg1) {
22618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22619     return 0;
22620   }
22621   {
22622     try {
22623       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22624     } catch (std::out_of_range& e) {
22625       {
22626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22627       };
22628     } catch (std::exception& e) {
22629       {
22630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22631       };
22632     } catch (...) {
22633       {
22634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22635       };
22636     }
22637   }
22638   jresult = (void *)result;
22639   return jresult;
22640 }
22641
22642
22643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22644   void * jresult ;
22645   Dali::BaseHandle arg1 ;
22646   Dali::BaseHandle *argp1 ;
22647   Dali::Geometry result;
22648
22649   argp1 = (Dali::BaseHandle *)jarg1;
22650   if (!argp1) {
22651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22652     return 0;
22653   }
22654   arg1 = *argp1;
22655   {
22656     try {
22657       result = Dali::Geometry::DownCast(arg1);
22658     } catch (std::out_of_range& e) {
22659       {
22660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22661       };
22662     } catch (std::exception& e) {
22663       {
22664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22665       };
22666     } catch (...) {
22667       {
22668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22669       };
22670     }
22671   }
22672   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22673   return jresult;
22674 }
22675
22676
22677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22678   void * jresult ;
22679   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22680   Dali::Geometry *arg2 = 0 ;
22681   Dali::Geometry *result = 0 ;
22682
22683   arg1 = (Dali::Geometry *)jarg1;
22684   arg2 = (Dali::Geometry *)jarg2;
22685   if (!arg2) {
22686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22687     return 0;
22688   }
22689   {
22690     try {
22691       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22692     } catch (std::out_of_range& e) {
22693       {
22694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22695       };
22696     } catch (std::exception& e) {
22697       {
22698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22699       };
22700     } catch (...) {
22701       {
22702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22703       };
22704     }
22705   }
22706   jresult = (void *)result;
22707   return jresult;
22708 }
22709
22710
22711 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22712   unsigned long jresult ;
22713   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22714   Dali::PropertyBuffer *arg2 = 0 ;
22715   std::size_t result;
22716
22717   arg1 = (Dali::Geometry *)jarg1;
22718   arg2 = (Dali::PropertyBuffer *)jarg2;
22719   if (!arg2) {
22720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22721     return 0;
22722   }
22723   {
22724     try {
22725       result = (arg1)->AddVertexBuffer(*arg2);
22726     } catch (std::out_of_range& e) {
22727       {
22728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22729       };
22730     } catch (std::exception& e) {
22731       {
22732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22733       };
22734     } catch (...) {
22735       {
22736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22737       };
22738     }
22739   }
22740   jresult = (unsigned long)result;
22741   return jresult;
22742 }
22743
22744
22745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22746   unsigned long jresult ;
22747   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22748   std::size_t result;
22749
22750   arg1 = (Dali::Geometry *)jarg1;
22751   {
22752     try {
22753       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22754     } catch (std::out_of_range& e) {
22755       {
22756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22757       };
22758     } catch (std::exception& e) {
22759       {
22760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22761       };
22762     } catch (...) {
22763       {
22764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22765       };
22766     }
22767   }
22768   jresult = (unsigned long)result;
22769   return jresult;
22770 }
22771
22772
22773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22774   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22775   std::size_t arg2 ;
22776
22777   arg1 = (Dali::Geometry *)jarg1;
22778   arg2 = (std::size_t)jarg2;
22779   {
22780     try {
22781       (arg1)->RemoveVertexBuffer(arg2);
22782     } catch (std::out_of_range& e) {
22783       {
22784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22785       };
22786     } catch (std::exception& e) {
22787       {
22788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22789       };
22790     } catch (...) {
22791       {
22792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22793       };
22794     }
22795   }
22796 }
22797
22798
22799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22800   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22801   unsigned short *arg2 = (unsigned short *) 0 ;
22802   size_t arg3 ;
22803
22804   arg1 = (Dali::Geometry *)jarg1;
22805   arg2 = jarg2;
22806   arg3 = (size_t)jarg3;
22807   {
22808     try {
22809       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22810     } catch (std::out_of_range& e) {
22811       {
22812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22813       };
22814     } catch (std::exception& e) {
22815       {
22816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22817       };
22818     } catch (...) {
22819       {
22820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22821       };
22822     }
22823   }
22824
22825
22826 }
22827
22828
22829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22830   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22831   Dali::Geometry::Type arg2 ;
22832
22833   arg1 = (Dali::Geometry *)jarg1;
22834   arg2 = (Dali::Geometry::Type)jarg2;
22835   {
22836     try {
22837       (arg1)->SetType(arg2);
22838     } catch (std::out_of_range& e) {
22839       {
22840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22841       };
22842     } catch (std::exception& e) {
22843       {
22844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22845       };
22846     } catch (...) {
22847       {
22848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22849       };
22850     }
22851   }
22852 }
22853
22854
22855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22856   int jresult ;
22857   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22858   Dali::Geometry::Type result;
22859
22860   arg1 = (Dali::Geometry *)jarg1;
22861   {
22862     try {
22863       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22864     } catch (std::out_of_range& e) {
22865       {
22866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22867       };
22868     } catch (std::exception& e) {
22869       {
22870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22871       };
22872     } catch (...) {
22873       {
22874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22875       };
22876     }
22877   }
22878   jresult = (int)result;
22879   return jresult;
22880 }
22881
22882
22883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22884   void * jresult ;
22885   Dali::Shader::Hint *result = 0 ;
22886
22887   {
22888     try {
22889       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22890     } catch (std::out_of_range& e) {
22891       {
22892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22893       };
22894     } catch (std::exception& e) {
22895       {
22896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22897       };
22898     } catch (...) {
22899       {
22900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22901       };
22902     }
22903   }
22904   jresult = (void *)result;
22905   return jresult;
22906 }
22907
22908
22909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22910   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22911
22912   arg1 = (Dali::Shader::Hint *)jarg1;
22913   {
22914     try {
22915       delete arg1;
22916     } catch (std::out_of_range& e) {
22917       {
22918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22919       };
22920     } catch (std::exception& e) {
22921       {
22922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22923       };
22924     } catch (...) {
22925       {
22926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22927       };
22928     }
22929   }
22930 }
22931
22932
22933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22934   int jresult ;
22935   int result;
22936
22937   result = (int)Dali::Shader::Property::PROGRAM;
22938   jresult = (int)result;
22939   return jresult;
22940 }
22941
22942
22943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
22944   void * jresult ;
22945   Dali::Shader::Property *result = 0 ;
22946
22947   {
22948     try {
22949       result = (Dali::Shader::Property *)new Dali::Shader::Property();
22950     } catch (std::out_of_range& e) {
22951       {
22952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22953       };
22954     } catch (std::exception& e) {
22955       {
22956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22957       };
22958     } catch (...) {
22959       {
22960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22961       };
22962     }
22963   }
22964   jresult = (void *)result;
22965   return jresult;
22966 }
22967
22968
22969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
22970   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
22971
22972   arg1 = (Dali::Shader::Property *)jarg1;
22973   {
22974     try {
22975       delete arg1;
22976     } catch (std::out_of_range& e) {
22977       {
22978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22979       };
22980     } catch (std::exception& e) {
22981       {
22982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22983       };
22984     } catch (...) {
22985       {
22986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22987       };
22988     }
22989   }
22990 }
22991
22992
22993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
22994   void * jresult ;
22995   std::string *arg1 = 0 ;
22996   std::string *arg2 = 0 ;
22997   Dali::Shader::Hint::Value arg3 ;
22998   Dali::Shader result;
22999
23000   if (!jarg1) {
23001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23002     return 0;
23003   }
23004   std::string arg1_str(jarg1);
23005   arg1 = &arg1_str;
23006   if (!jarg2) {
23007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23008     return 0;
23009   }
23010   std::string arg2_str(jarg2);
23011   arg2 = &arg2_str;
23012   arg3 = (Dali::Shader::Hint::Value)jarg3;
23013   {
23014     try {
23015       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23016     } catch (std::out_of_range& e) {
23017       {
23018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23019       };
23020     } catch (std::exception& e) {
23021       {
23022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23023       };
23024     } catch (...) {
23025       {
23026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23027       };
23028     }
23029   }
23030   jresult = new Dali::Shader((const Dali::Shader &)result);
23031
23032   //argout typemap for const std::string&
23033
23034
23035   //argout typemap for const std::string&
23036
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23042   void * jresult ;
23043   std::string *arg1 = 0 ;
23044   std::string *arg2 = 0 ;
23045   Dali::Shader result;
23046
23047   if (!jarg1) {
23048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23049     return 0;
23050   }
23051   std::string arg1_str(jarg1);
23052   arg1 = &arg1_str;
23053   if (!jarg2) {
23054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23055     return 0;
23056   }
23057   std::string arg2_str(jarg2);
23058   arg2 = &arg2_str;
23059   {
23060     try {
23061       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23062     } catch (std::out_of_range& e) {
23063       {
23064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23065       };
23066     } catch (std::exception& e) {
23067       {
23068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23069       };
23070     } catch (...) {
23071       {
23072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23073       };
23074     }
23075   }
23076   jresult = new Dali::Shader((const Dali::Shader &)result);
23077
23078   //argout typemap for const std::string&
23079
23080
23081   //argout typemap for const std::string&
23082
23083   return jresult;
23084 }
23085
23086
23087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23088   void * jresult ;
23089   Dali::Shader *result = 0 ;
23090
23091   {
23092     try {
23093       result = (Dali::Shader *)new Dali::Shader();
23094     } catch (std::out_of_range& e) {
23095       {
23096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23097       };
23098     } catch (std::exception& e) {
23099       {
23100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23101       };
23102     } catch (...) {
23103       {
23104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23105       };
23106     }
23107   }
23108   jresult = (void *)result;
23109   return jresult;
23110 }
23111
23112
23113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23114   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23115
23116   arg1 = (Dali::Shader *)jarg1;
23117   {
23118     try {
23119       delete arg1;
23120     } catch (std::out_of_range& e) {
23121       {
23122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23123       };
23124     } catch (std::exception& e) {
23125       {
23126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23127       };
23128     } catch (...) {
23129       {
23130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23131       };
23132     }
23133   }
23134 }
23135
23136
23137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23138   void * jresult ;
23139   Dali::Shader *arg1 = 0 ;
23140   Dali::Shader *result = 0 ;
23141
23142   arg1 = (Dali::Shader *)jarg1;
23143   if (!arg1) {
23144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23145     return 0;
23146   }
23147   {
23148     try {
23149       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23150     } catch (std::out_of_range& e) {
23151       {
23152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23153       };
23154     } catch (std::exception& e) {
23155       {
23156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23157       };
23158     } catch (...) {
23159       {
23160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23161       };
23162     }
23163   }
23164   jresult = (void *)result;
23165   return jresult;
23166 }
23167
23168
23169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23170   void * jresult ;
23171   Dali::BaseHandle arg1 ;
23172   Dali::BaseHandle *argp1 ;
23173   Dali::Shader result;
23174
23175   argp1 = (Dali::BaseHandle *)jarg1;
23176   if (!argp1) {
23177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23178     return 0;
23179   }
23180   arg1 = *argp1;
23181   {
23182     try {
23183       result = Dali::Shader::DownCast(arg1);
23184     } catch (std::out_of_range& e) {
23185       {
23186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23187       };
23188     } catch (std::exception& e) {
23189       {
23190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23191       };
23192     } catch (...) {
23193       {
23194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23195       };
23196     }
23197   }
23198   jresult = new Dali::Shader((const Dali::Shader &)result);
23199   return jresult;
23200 }
23201
23202
23203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23204   void * jresult ;
23205   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23206   Dali::Shader *arg2 = 0 ;
23207   Dali::Shader *result = 0 ;
23208
23209   arg1 = (Dali::Shader *)jarg1;
23210   arg2 = (Dali::Shader *)jarg2;
23211   if (!arg2) {
23212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23213     return 0;
23214   }
23215   {
23216     try {
23217       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23218     } catch (std::out_of_range& e) {
23219       {
23220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23221       };
23222     } catch (std::exception& e) {
23223       {
23224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23225       };
23226     } catch (...) {
23227       {
23228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23229       };
23230     }
23231   }
23232   jresult = (void *)result;
23233   return jresult;
23234 }
23235
23236
23237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23238   int jresult ;
23239   int result;
23240
23241   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23242   jresult = (int)result;
23243   return jresult;
23244 }
23245
23246
23247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23248   int jresult ;
23249   int result;
23250
23251   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23252   jresult = (int)result;
23253   return jresult;
23254 }
23255
23256
23257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23258   int jresult ;
23259   int result;
23260
23261   result = (int)Dali::Renderer::Property::BLEND_MODE;
23262   jresult = (int)result;
23263   return jresult;
23264 }
23265
23266
23267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23268   int jresult ;
23269   int result;
23270
23271   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23272   jresult = (int)result;
23273   return jresult;
23274 }
23275
23276
23277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23278   int jresult ;
23279   int result;
23280
23281   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23282   jresult = (int)result;
23283   return jresult;
23284 }
23285
23286
23287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23288   int jresult ;
23289   int result;
23290
23291   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23292   jresult = (int)result;
23293   return jresult;
23294 }
23295
23296
23297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23298   int jresult ;
23299   int result;
23300
23301   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23302   jresult = (int)result;
23303   return jresult;
23304 }
23305
23306
23307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23308   int jresult ;
23309   int result;
23310
23311   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23312   jresult = (int)result;
23313   return jresult;
23314 }
23315
23316
23317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23318   int jresult ;
23319   int result;
23320
23321   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23322   jresult = (int)result;
23323   return jresult;
23324 }
23325
23326
23327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23328   int jresult ;
23329   int result;
23330
23331   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23332   jresult = (int)result;
23333   return jresult;
23334 }
23335
23336
23337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23338   int jresult ;
23339   int result;
23340
23341   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23342   jresult = (int)result;
23343   return jresult;
23344 }
23345
23346
23347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23348   int jresult ;
23349   int result;
23350
23351   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23352   jresult = (int)result;
23353   return jresult;
23354 }
23355
23356
23357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23358   int jresult ;
23359   int result;
23360
23361   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23362   jresult = (int)result;
23363   return jresult;
23364 }
23365
23366
23367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23368   int jresult ;
23369   int result;
23370
23371   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23372   jresult = (int)result;
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23378   int jresult ;
23379   int result;
23380
23381   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23382   jresult = (int)result;
23383   return jresult;
23384 }
23385
23386
23387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23388   int jresult ;
23389   int result;
23390
23391   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23392   jresult = (int)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23398   int jresult ;
23399   int result;
23400
23401   result = (int)Dali::Renderer::Property::RENDER_MODE;
23402   jresult = (int)result;
23403   return jresult;
23404 }
23405
23406
23407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23408   int jresult ;
23409   int result;
23410
23411   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23412   jresult = (int)result;
23413   return jresult;
23414 }
23415
23416
23417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23418   int jresult ;
23419   int result;
23420
23421   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23422   jresult = (int)result;
23423   return jresult;
23424 }
23425
23426
23427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23428   int jresult ;
23429   int result;
23430
23431   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23432   jresult = (int)result;
23433   return jresult;
23434 }
23435
23436
23437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23438   int jresult ;
23439   int result;
23440
23441   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23442   jresult = (int)result;
23443   return jresult;
23444 }
23445
23446
23447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23448   int jresult ;
23449   int result;
23450
23451   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23452   jresult = (int)result;
23453   return jresult;
23454 }
23455
23456
23457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23458   int jresult ;
23459   int result;
23460
23461   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23462   jresult = (int)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23468   int jresult ;
23469   int result;
23470
23471   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23472   jresult = (int)result;
23473   return jresult;
23474 }
23475
23476
23477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23478   void * jresult ;
23479   Dali::Renderer::Property *result = 0 ;
23480
23481   {
23482     try {
23483       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23484     } catch (std::out_of_range& e) {
23485       {
23486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23487       };
23488     } catch (std::exception& e) {
23489       {
23490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23491       };
23492     } catch (...) {
23493       {
23494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23495       };
23496     }
23497   }
23498   jresult = (void *)result;
23499   return jresult;
23500 }
23501
23502
23503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23504   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23505
23506   arg1 = (Dali::Renderer::Property *)jarg1;
23507   {
23508     try {
23509       delete arg1;
23510     } catch (std::out_of_range& e) {
23511       {
23512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23513       };
23514     } catch (std::exception& e) {
23515       {
23516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23517       };
23518     } catch (...) {
23519       {
23520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23521       };
23522     }
23523   }
23524 }
23525
23526
23527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23528   void * jresult ;
23529   Dali::Geometry *arg1 = 0 ;
23530   Dali::Shader *arg2 = 0 ;
23531   Dali::Renderer result;
23532
23533   arg1 = (Dali::Geometry *)jarg1;
23534   if (!arg1) {
23535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23536     return 0;
23537   }
23538   arg2 = (Dali::Shader *)jarg2;
23539   if (!arg2) {
23540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23541     return 0;
23542   }
23543   {
23544     try {
23545       result = Dali::Renderer::New(*arg1,*arg2);
23546     } catch (std::out_of_range& e) {
23547       {
23548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23549       };
23550     } catch (std::exception& e) {
23551       {
23552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23553       };
23554     } catch (...) {
23555       {
23556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23557       };
23558     }
23559   }
23560   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23561   return jresult;
23562 }
23563
23564
23565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23566   void * jresult ;
23567   Dali::Renderer *result = 0 ;
23568
23569   {
23570     try {
23571       result = (Dali::Renderer *)new Dali::Renderer();
23572     } catch (std::out_of_range& e) {
23573       {
23574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23575       };
23576     } catch (std::exception& e) {
23577       {
23578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23579       };
23580     } catch (...) {
23581       {
23582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23583       };
23584     }
23585   }
23586   jresult = (void *)result;
23587   return jresult;
23588 }
23589
23590
23591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23592   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23593
23594   arg1 = (Dali::Renderer *)jarg1;
23595   {
23596     try {
23597       delete arg1;
23598     } catch (std::out_of_range& e) {
23599       {
23600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23601       };
23602     } catch (std::exception& e) {
23603       {
23604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23605       };
23606     } catch (...) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23609       };
23610     }
23611   }
23612 }
23613
23614
23615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23616   void * jresult ;
23617   Dali::Renderer *arg1 = 0 ;
23618   Dali::Renderer *result = 0 ;
23619
23620   arg1 = (Dali::Renderer *)jarg1;
23621   if (!arg1) {
23622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23623     return 0;
23624   }
23625   {
23626     try {
23627       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23628     } catch (std::out_of_range& e) {
23629       {
23630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23631       };
23632     } catch (std::exception& e) {
23633       {
23634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23635       };
23636     } catch (...) {
23637       {
23638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23639       };
23640     }
23641   }
23642   jresult = (void *)result;
23643   return jresult;
23644 }
23645
23646
23647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23648   void * jresult ;
23649   Dali::BaseHandle arg1 ;
23650   Dali::BaseHandle *argp1 ;
23651   Dali::Renderer result;
23652
23653   argp1 = (Dali::BaseHandle *)jarg1;
23654   if (!argp1) {
23655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23656     return 0;
23657   }
23658   arg1 = *argp1;
23659   {
23660     try {
23661       result = Dali::Renderer::DownCast(arg1);
23662     } catch (std::out_of_range& e) {
23663       {
23664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23665       };
23666     } catch (std::exception& e) {
23667       {
23668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23669       };
23670     } catch (...) {
23671       {
23672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23673       };
23674     }
23675   }
23676   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23677   return jresult;
23678 }
23679
23680
23681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23682   void * jresult ;
23683   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23684   Dali::Renderer *arg2 = 0 ;
23685   Dali::Renderer *result = 0 ;
23686
23687   arg1 = (Dali::Renderer *)jarg1;
23688   arg2 = (Dali::Renderer *)jarg2;
23689   if (!arg2) {
23690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23691     return 0;
23692   }
23693   {
23694     try {
23695       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23696     } catch (std::out_of_range& e) {
23697       {
23698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23699       };
23700     } catch (std::exception& e) {
23701       {
23702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23703       };
23704     } catch (...) {
23705       {
23706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23707       };
23708     }
23709   }
23710   jresult = (void *)result;
23711   return jresult;
23712 }
23713
23714
23715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23716   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23717   Dali::Geometry *arg2 = 0 ;
23718
23719   arg1 = (Dali::Renderer *)jarg1;
23720   arg2 = (Dali::Geometry *)jarg2;
23721   if (!arg2) {
23722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23723     return ;
23724   }
23725   {
23726     try {
23727       (arg1)->SetGeometry(*arg2);
23728     } catch (std::out_of_range& e) {
23729       {
23730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23731       };
23732     } catch (std::exception& e) {
23733       {
23734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23735       };
23736     } catch (...) {
23737       {
23738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23739       };
23740     }
23741   }
23742 }
23743
23744
23745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23746   void * jresult ;
23747   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23748   Dali::Geometry result;
23749
23750   arg1 = (Dali::Renderer *)jarg1;
23751   {
23752     try {
23753       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23754     } catch (std::out_of_range& e) {
23755       {
23756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23757       };
23758     } catch (std::exception& e) {
23759       {
23760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23761       };
23762     } catch (...) {
23763       {
23764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23765       };
23766     }
23767   }
23768   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23769   return jresult;
23770 }
23771
23772
23773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23774   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23775   int arg2 ;
23776   int arg3 ;
23777
23778   arg1 = (Dali::Renderer *)jarg1;
23779   arg2 = (int)jarg2;
23780   arg3 = (int)jarg3;
23781   {
23782     try {
23783       (arg1)->SetIndexRange(arg2,arg3);
23784     } catch (std::out_of_range& e) {
23785       {
23786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23787       };
23788     } catch (std::exception& e) {
23789       {
23790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23791       };
23792     } catch (...) {
23793       {
23794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23795       };
23796     }
23797   }
23798 }
23799
23800
23801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23802   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23803   Dali::TextureSet *arg2 = 0 ;
23804
23805   arg1 = (Dali::Renderer *)jarg1;
23806   arg2 = (Dali::TextureSet *)jarg2;
23807   if (!arg2) {
23808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23809     return ;
23810   }
23811   {
23812     try {
23813       (arg1)->SetTextures(*arg2);
23814     } catch (std::out_of_range& e) {
23815       {
23816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23817       };
23818     } catch (std::exception& e) {
23819       {
23820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23821       };
23822     } catch (...) {
23823       {
23824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23825       };
23826     }
23827   }
23828 }
23829
23830
23831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23832   void * jresult ;
23833   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23834   Dali::TextureSet result;
23835
23836   arg1 = (Dali::Renderer *)jarg1;
23837   {
23838     try {
23839       result = ((Dali::Renderer const *)arg1)->GetTextures();
23840     } catch (std::out_of_range& e) {
23841       {
23842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23843       };
23844     } catch (std::exception& e) {
23845       {
23846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23847       };
23848     } catch (...) {
23849       {
23850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23851       };
23852     }
23853   }
23854   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23855   return jresult;
23856 }
23857
23858
23859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23860   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23861   Dali::Shader *arg2 = 0 ;
23862
23863   arg1 = (Dali::Renderer *)jarg1;
23864   arg2 = (Dali::Shader *)jarg2;
23865   if (!arg2) {
23866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23867     return ;
23868   }
23869   {
23870     try {
23871       (arg1)->SetShader(*arg2);
23872     } catch (std::out_of_range& e) {
23873       {
23874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23875       };
23876     } catch (std::exception& e) {
23877       {
23878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23879       };
23880     } catch (...) {
23881       {
23882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23883       };
23884     }
23885   }
23886 }
23887
23888
23889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23890   void * jresult ;
23891   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23892   Dali::Shader result;
23893
23894   arg1 = (Dali::Renderer *)jarg1;
23895   {
23896     try {
23897       result = ((Dali::Renderer const *)arg1)->GetShader();
23898     } catch (std::out_of_range& e) {
23899       {
23900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23901       };
23902     } catch (std::exception& e) {
23903       {
23904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23905       };
23906     } catch (...) {
23907       {
23908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23909       };
23910     }
23911   }
23912   jresult = new Dali::Shader((const Dali::Shader &)result);
23913   return jresult;
23914 }
23915
23916
23917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23918   void * jresult ;
23919   Dali::FrameBuffer::Attachment *result = 0 ;
23920
23921   {
23922     try {
23923       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23924     } catch (std::out_of_range& e) {
23925       {
23926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23927       };
23928     } catch (std::exception& e) {
23929       {
23930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23931       };
23932     } catch (...) {
23933       {
23934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23935       };
23936     }
23937   }
23938   jresult = (void *)result;
23939   return jresult;
23940 }
23941
23942
23943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
23944   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
23945
23946   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
23947   {
23948     try {
23949       delete arg1;
23950     } catch (std::out_of_range& e) {
23951       {
23952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23953       };
23954     } catch (std::exception& e) {
23955       {
23956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23957       };
23958     } catch (...) {
23959       {
23960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23961       };
23962     }
23963   }
23964 }
23965
23966
23967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
23968   void * jresult ;
23969   unsigned int arg1 ;
23970   unsigned int arg2 ;
23971   unsigned int arg3 ;
23972   Dali::FrameBuffer result;
23973
23974   arg1 = (unsigned int)jarg1;
23975   arg2 = (unsigned int)jarg2;
23976   arg3 = (unsigned int)jarg3;
23977   {
23978     try {
23979       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
23980     } catch (std::out_of_range& e) {
23981       {
23982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23983       };
23984     } catch (std::exception& e) {
23985       {
23986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (...) {
23989       {
23990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23991       };
23992     }
23993   }
23994   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
23995   return jresult;
23996 }
23997
23998
23999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24000   void * jresult ;
24001   Dali::FrameBuffer *result = 0 ;
24002
24003   {
24004     try {
24005       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24006     } catch (std::out_of_range& e) {
24007       {
24008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24009       };
24010     } catch (std::exception& e) {
24011       {
24012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24013       };
24014     } catch (...) {
24015       {
24016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24017       };
24018     }
24019   }
24020   jresult = (void *)result;
24021   return jresult;
24022 }
24023
24024
24025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24026   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24027
24028   arg1 = (Dali::FrameBuffer *)jarg1;
24029   {
24030     try {
24031       delete arg1;
24032     } catch (std::out_of_range& e) {
24033       {
24034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24035       };
24036     } catch (std::exception& e) {
24037       {
24038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24039       };
24040     } catch (...) {
24041       {
24042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24043       };
24044     }
24045   }
24046 }
24047
24048
24049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24050   void * jresult ;
24051   Dali::FrameBuffer *arg1 = 0 ;
24052   Dali::FrameBuffer *result = 0 ;
24053
24054   arg1 = (Dali::FrameBuffer *)jarg1;
24055   if (!arg1) {
24056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24057     return 0;
24058   }
24059   {
24060     try {
24061       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24062     } catch (std::out_of_range& e) {
24063       {
24064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24065       };
24066     } catch (std::exception& e) {
24067       {
24068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24069       };
24070     } catch (...) {
24071       {
24072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24073       };
24074     }
24075   }
24076   jresult = (void *)result;
24077   return jresult;
24078 }
24079
24080
24081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24082   void * jresult ;
24083   Dali::BaseHandle arg1 ;
24084   Dali::BaseHandle *argp1 ;
24085   Dali::FrameBuffer result;
24086
24087   argp1 = (Dali::BaseHandle *)jarg1;
24088   if (!argp1) {
24089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24090     return 0;
24091   }
24092   arg1 = *argp1;
24093   {
24094     try {
24095       result = Dali::FrameBuffer::DownCast(arg1);
24096     } catch (std::out_of_range& e) {
24097       {
24098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24099       };
24100     } catch (std::exception& e) {
24101       {
24102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24103       };
24104     } catch (...) {
24105       {
24106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24107       };
24108     }
24109   }
24110   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24111   return jresult;
24112 }
24113
24114
24115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24116   void * jresult ;
24117   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24118   Dali::FrameBuffer *arg2 = 0 ;
24119   Dali::FrameBuffer *result = 0 ;
24120
24121   arg1 = (Dali::FrameBuffer *)jarg1;
24122   arg2 = (Dali::FrameBuffer *)jarg2;
24123   if (!arg2) {
24124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24125     return 0;
24126   }
24127   {
24128     try {
24129       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24130     } catch (std::out_of_range& e) {
24131       {
24132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24133       };
24134     } catch (std::exception& e) {
24135       {
24136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24137       };
24138     } catch (...) {
24139       {
24140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24141       };
24142     }
24143   }
24144   jresult = (void *)result;
24145   return jresult;
24146 }
24147
24148
24149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24150   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24151   Dali::Texture *arg2 = 0 ;
24152
24153   arg1 = (Dali::FrameBuffer *)jarg1;
24154   arg2 = (Dali::Texture *)jarg2;
24155   if (!arg2) {
24156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24157     return ;
24158   }
24159   {
24160     try {
24161       (arg1)->AttachColorTexture(*arg2);
24162     } catch (std::out_of_range& e) {
24163       {
24164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24165       };
24166     } catch (std::exception& e) {
24167       {
24168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24169       };
24170     } catch (...) {
24171       {
24172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24173       };
24174     }
24175   }
24176 }
24177
24178
24179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24180   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24181   Dali::Texture *arg2 = 0 ;
24182   unsigned int arg3 ;
24183   unsigned int arg4 ;
24184
24185   arg1 = (Dali::FrameBuffer *)jarg1;
24186   arg2 = (Dali::Texture *)jarg2;
24187   if (!arg2) {
24188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24189     return ;
24190   }
24191   arg3 = (unsigned int)jarg3;
24192   arg4 = (unsigned int)jarg4;
24193   {
24194     try {
24195       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24196     } catch (std::out_of_range& e) {
24197       {
24198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24199       };
24200     } catch (std::exception& e) {
24201       {
24202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24203       };
24204     } catch (...) {
24205       {
24206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24207       };
24208     }
24209   }
24210 }
24211
24212
24213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24214   void * jresult ;
24215   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24216   Dali::Texture result;
24217
24218   arg1 = (Dali::FrameBuffer *)jarg1;
24219   {
24220     try {
24221       result = (arg1)->GetColorTexture();
24222     } catch (std::out_of_range& e) {
24223       {
24224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24225       };
24226     } catch (std::exception& e) {
24227       {
24228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24229       };
24230     } catch (...) {
24231       {
24232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24233       };
24234     }
24235   }
24236   jresult = new Dali::Texture((const Dali::Texture &)result);
24237   return jresult;
24238 }
24239
24240
24241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24242   void * jresult ;
24243   Dali::RenderTaskList *result = 0 ;
24244
24245   {
24246     try {
24247       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24248     } catch (std::out_of_range& e) {
24249       {
24250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24251       };
24252     } catch (std::exception& e) {
24253       {
24254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24255       };
24256     } catch (...) {
24257       {
24258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24259       };
24260     }
24261   }
24262   jresult = (void *)result;
24263   return jresult;
24264 }
24265
24266
24267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24268   void * jresult ;
24269   Dali::BaseHandle arg1 ;
24270   Dali::BaseHandle *argp1 ;
24271   Dali::RenderTaskList result;
24272
24273   argp1 = (Dali::BaseHandle *)jarg1;
24274   if (!argp1) {
24275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24276     return 0;
24277   }
24278   arg1 = *argp1;
24279   {
24280     try {
24281       result = Dali::RenderTaskList::DownCast(arg1);
24282     } catch (std::out_of_range& e) {
24283       {
24284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24285       };
24286     } catch (std::exception& e) {
24287       {
24288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24289       };
24290     } catch (...) {
24291       {
24292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24293       };
24294     }
24295   }
24296   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24297   return jresult;
24298 }
24299
24300
24301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24302   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24303
24304   arg1 = (Dali::RenderTaskList *)jarg1;
24305   {
24306     try {
24307       delete arg1;
24308     } catch (std::out_of_range& e) {
24309       {
24310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24311       };
24312     } catch (std::exception& e) {
24313       {
24314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24315       };
24316     } catch (...) {
24317       {
24318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24319       };
24320     }
24321   }
24322 }
24323
24324
24325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24326   void * jresult ;
24327   Dali::RenderTaskList *arg1 = 0 ;
24328   Dali::RenderTaskList *result = 0 ;
24329
24330   arg1 = (Dali::RenderTaskList *)jarg1;
24331   if (!arg1) {
24332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24333     return 0;
24334   }
24335   {
24336     try {
24337       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24338     } catch (std::out_of_range& e) {
24339       {
24340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24341       };
24342     } catch (std::exception& e) {
24343       {
24344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24345       };
24346     } catch (...) {
24347       {
24348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24349       };
24350     }
24351   }
24352   jresult = (void *)result;
24353   return jresult;
24354 }
24355
24356
24357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24358   void * jresult ;
24359   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24360   Dali::RenderTaskList *arg2 = 0 ;
24361   Dali::RenderTaskList *result = 0 ;
24362
24363   arg1 = (Dali::RenderTaskList *)jarg1;
24364   arg2 = (Dali::RenderTaskList *)jarg2;
24365   if (!arg2) {
24366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24367     return 0;
24368   }
24369   {
24370     try {
24371       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24372     } catch (std::out_of_range& e) {
24373       {
24374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24375       };
24376     } catch (std::exception& e) {
24377       {
24378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24379       };
24380     } catch (...) {
24381       {
24382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24383       };
24384     }
24385   }
24386   jresult = (void *)result;
24387   return jresult;
24388 }
24389
24390
24391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24392   void * jresult ;
24393   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24394   Dali::RenderTask result;
24395
24396   arg1 = (Dali::RenderTaskList *)jarg1;
24397   {
24398     try {
24399       result = (arg1)->CreateTask();
24400     } catch (std::out_of_range& e) {
24401       {
24402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24403       };
24404     } catch (std::exception& e) {
24405       {
24406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24407       };
24408     } catch (...) {
24409       {
24410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24411       };
24412     }
24413   }
24414   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24415   return jresult;
24416 }
24417
24418
24419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24420   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24421   Dali::RenderTask arg2 ;
24422   Dali::RenderTask *argp2 ;
24423
24424   arg1 = (Dali::RenderTaskList *)jarg1;
24425   argp2 = (Dali::RenderTask *)jarg2;
24426   if (!argp2) {
24427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24428     return ;
24429   }
24430   arg2 = *argp2;
24431   {
24432     try {
24433       (arg1)->RemoveTask(arg2);
24434     } catch (std::out_of_range& e) {
24435       {
24436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24437       };
24438     } catch (std::exception& e) {
24439       {
24440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24441       };
24442     } catch (...) {
24443       {
24444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24445       };
24446     }
24447   }
24448 }
24449
24450
24451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24452   unsigned int jresult ;
24453   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24454   unsigned int result;
24455
24456   arg1 = (Dali::RenderTaskList *)jarg1;
24457   {
24458     try {
24459       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24460     } catch (std::out_of_range& e) {
24461       {
24462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24463       };
24464     } catch (std::exception& e) {
24465       {
24466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24467       };
24468     } catch (...) {
24469       {
24470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24471       };
24472     }
24473   }
24474   jresult = result;
24475   return jresult;
24476 }
24477
24478
24479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24480   void * jresult ;
24481   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24482   unsigned int arg2 ;
24483   Dali::RenderTask result;
24484
24485   arg1 = (Dali::RenderTaskList *)jarg1;
24486   arg2 = (unsigned int)jarg2;
24487   {
24488     try {
24489       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24490     } catch (std::out_of_range& e) {
24491       {
24492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24493       };
24494     } catch (std::exception& e) {
24495       {
24496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24497       };
24498     } catch (...) {
24499       {
24500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24501       };
24502     }
24503   }
24504   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24505   return jresult;
24506 }
24507
24508
24509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24510   int jresult ;
24511   int result;
24512
24513   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24514   jresult = (int)result;
24515   return jresult;
24516 }
24517
24518
24519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24520   int jresult ;
24521   int result;
24522
24523   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24524   jresult = (int)result;
24525   return jresult;
24526 }
24527
24528
24529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24530   int jresult ;
24531   int result;
24532
24533   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24534   jresult = (int)result;
24535   return jresult;
24536 }
24537
24538
24539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24540   int jresult ;
24541   int result;
24542
24543   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24544   jresult = (int)result;
24545   return jresult;
24546 }
24547
24548
24549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24550   void * jresult ;
24551   Dali::RenderTask::Property *result = 0 ;
24552
24553   {
24554     try {
24555       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24556     } catch (std::out_of_range& e) {
24557       {
24558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24559       };
24560     } catch (std::exception& e) {
24561       {
24562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24563       };
24564     } catch (...) {
24565       {
24566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24567       };
24568     }
24569   }
24570   jresult = (void *)result;
24571   return jresult;
24572 }
24573
24574
24575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24576   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24577
24578   arg1 = (Dali::RenderTask::Property *)jarg1;
24579   {
24580     try {
24581       delete arg1;
24582     } catch (std::out_of_range& e) {
24583       {
24584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24585       };
24586     } catch (std::exception& e) {
24587       {
24588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24589       };
24590     } catch (...) {
24591       {
24592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24593       };
24594     }
24595   }
24596 }
24597
24598
24599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24600   void * jresult ;
24601   bool (*result)(Dali::Vector2 &) = 0 ;
24602
24603   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24604   jresult = (void *)result;
24605   return jresult;
24606 }
24607
24608
24609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24610   void * jresult ;
24611   bool (*result)(Dali::Vector2 &) = 0 ;
24612
24613   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24614   jresult = (void *)result;
24615   return jresult;
24616 }
24617
24618
24619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24620   unsigned int jresult ;
24621   bool result;
24622
24623   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24624   jresult = result;
24625   return jresult;
24626 }
24627
24628
24629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24630   unsigned int jresult ;
24631   bool result;
24632
24633   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24634   jresult = result;
24635   return jresult;
24636 }
24637
24638
24639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24640   void * jresult ;
24641   Dali::Vector4 *result = 0 ;
24642
24643   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24644   jresult = (void *)result;
24645   return jresult;
24646 }
24647
24648
24649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24650   unsigned int jresult ;
24651   bool result;
24652
24653   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24654   jresult = result;
24655   return jresult;
24656 }
24657
24658
24659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24660   unsigned int jresult ;
24661   bool result;
24662
24663   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24664   jresult = result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24670   unsigned int jresult ;
24671   unsigned int result;
24672
24673   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24674   jresult = result;
24675   return jresult;
24676 }
24677
24678
24679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24680   void * jresult ;
24681   Dali::RenderTask *result = 0 ;
24682
24683   {
24684     try {
24685       result = (Dali::RenderTask *)new Dali::RenderTask();
24686     } catch (std::out_of_range& e) {
24687       {
24688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24689       };
24690     } catch (std::exception& e) {
24691       {
24692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24693       };
24694     } catch (...) {
24695       {
24696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24697       };
24698     }
24699   }
24700   jresult = (void *)result;
24701   return jresult;
24702 }
24703
24704
24705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24706   void * jresult ;
24707   Dali::BaseHandle arg1 ;
24708   Dali::BaseHandle *argp1 ;
24709   Dali::RenderTask result;
24710
24711   argp1 = (Dali::BaseHandle *)jarg1;
24712   if (!argp1) {
24713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24714     return 0;
24715   }
24716   arg1 = *argp1;
24717   {
24718     try {
24719       result = Dali::RenderTask::DownCast(arg1);
24720     } catch (std::out_of_range& e) {
24721       {
24722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24723       };
24724     } catch (std::exception& e) {
24725       {
24726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24727       };
24728     } catch (...) {
24729       {
24730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24731       };
24732     }
24733   }
24734   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24735   return jresult;
24736 }
24737
24738
24739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24740   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24741
24742   arg1 = (Dali::RenderTask *)jarg1;
24743   {
24744     try {
24745       delete arg1;
24746     } catch (std::out_of_range& e) {
24747       {
24748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24749       };
24750     } catch (std::exception& e) {
24751       {
24752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24753       };
24754     } catch (...) {
24755       {
24756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24757       };
24758     }
24759   }
24760 }
24761
24762
24763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24764   void * jresult ;
24765   Dali::RenderTask *arg1 = 0 ;
24766   Dali::RenderTask *result = 0 ;
24767
24768   arg1 = (Dali::RenderTask *)jarg1;
24769   if (!arg1) {
24770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24771     return 0;
24772   }
24773   {
24774     try {
24775       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24776     } catch (std::out_of_range& e) {
24777       {
24778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24779       };
24780     } catch (std::exception& e) {
24781       {
24782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24783       };
24784     } catch (...) {
24785       {
24786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24787       };
24788     }
24789   }
24790   jresult = (void *)result;
24791   return jresult;
24792 }
24793
24794
24795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24796   void * jresult ;
24797   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24798   Dali::RenderTask *arg2 = 0 ;
24799   Dali::RenderTask *result = 0 ;
24800
24801   arg1 = (Dali::RenderTask *)jarg1;
24802   arg2 = (Dali::RenderTask *)jarg2;
24803   if (!arg2) {
24804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24805     return 0;
24806   }
24807   {
24808     try {
24809       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24810     } catch (std::out_of_range& e) {
24811       {
24812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24813       };
24814     } catch (std::exception& e) {
24815       {
24816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24817       };
24818     } catch (...) {
24819       {
24820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24821       };
24822     }
24823   }
24824   jresult = (void *)result;
24825   return jresult;
24826 }
24827
24828
24829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24830   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24831   Dali::Actor arg2 ;
24832   Dali::Actor *argp2 ;
24833
24834   arg1 = (Dali::RenderTask *)jarg1;
24835   argp2 = (Dali::Actor *)jarg2;
24836   if (!argp2) {
24837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24838     return ;
24839   }
24840   arg2 = *argp2;
24841   {
24842     try {
24843       (arg1)->SetSourceActor(arg2);
24844     } catch (std::out_of_range& e) {
24845       {
24846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24847       };
24848     } catch (std::exception& e) {
24849       {
24850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24851       };
24852     } catch (...) {
24853       {
24854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24855       };
24856     }
24857   }
24858 }
24859
24860
24861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24862   void * jresult ;
24863   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24864   Dali::Actor result;
24865
24866   arg1 = (Dali::RenderTask *)jarg1;
24867   {
24868     try {
24869       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24870     } catch (std::out_of_range& e) {
24871       {
24872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24873       };
24874     } catch (std::exception& e) {
24875       {
24876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24877       };
24878     } catch (...) {
24879       {
24880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24881       };
24882     }
24883   }
24884   jresult = new Dali::Actor((const Dali::Actor &)result);
24885   return jresult;
24886 }
24887
24888
24889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24890   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24891   bool arg2 ;
24892
24893   arg1 = (Dali::RenderTask *)jarg1;
24894   arg2 = jarg2 ? true : false;
24895   {
24896     try {
24897       (arg1)->SetExclusive(arg2);
24898     } catch (std::out_of_range& e) {
24899       {
24900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24901       };
24902     } catch (std::exception& e) {
24903       {
24904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24905       };
24906     } catch (...) {
24907       {
24908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24909       };
24910     }
24911   }
24912 }
24913
24914
24915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24916   unsigned int jresult ;
24917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24918   bool result;
24919
24920   arg1 = (Dali::RenderTask *)jarg1;
24921   {
24922     try {
24923       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24924     } catch (std::out_of_range& e) {
24925       {
24926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24927       };
24928     } catch (std::exception& e) {
24929       {
24930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24931       };
24932     } catch (...) {
24933       {
24934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24935       };
24936     }
24937   }
24938   jresult = result;
24939   return jresult;
24940 }
24941
24942
24943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
24944   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24945   bool arg2 ;
24946
24947   arg1 = (Dali::RenderTask *)jarg1;
24948   arg2 = jarg2 ? true : false;
24949   {
24950     try {
24951       (arg1)->SetInputEnabled(arg2);
24952     } catch (std::out_of_range& e) {
24953       {
24954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24955       };
24956     } catch (std::exception& e) {
24957       {
24958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24959       };
24960     } catch (...) {
24961       {
24962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24963       };
24964     }
24965   }
24966 }
24967
24968
24969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
24970   unsigned int jresult ;
24971   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24972   bool result;
24973
24974   arg1 = (Dali::RenderTask *)jarg1;
24975   {
24976     try {
24977       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
24978     } catch (std::out_of_range& e) {
24979       {
24980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24981       };
24982     } catch (std::exception& e) {
24983       {
24984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24985       };
24986     } catch (...) {
24987       {
24988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24989       };
24990     }
24991   }
24992   jresult = result;
24993   return jresult;
24994 }
24995
24996
24997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
24998   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24999   Dali::CameraActor arg2 ;
25000   Dali::CameraActor *argp2 ;
25001
25002   arg1 = (Dali::RenderTask *)jarg1;
25003   argp2 = (Dali::CameraActor *)jarg2;
25004   if (!argp2) {
25005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25006     return ;
25007   }
25008   arg2 = *argp2;
25009   {
25010     try {
25011       (arg1)->SetCameraActor(arg2);
25012     } catch (std::out_of_range& e) {
25013       {
25014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25015       };
25016     } catch (std::exception& e) {
25017       {
25018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25019       };
25020     } catch (...) {
25021       {
25022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25023       };
25024     }
25025   }
25026 }
25027
25028
25029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25030   void * jresult ;
25031   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25032   Dali::CameraActor result;
25033
25034   arg1 = (Dali::RenderTask *)jarg1;
25035   {
25036     try {
25037       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25038     } catch (std::out_of_range& e) {
25039       {
25040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25041       };
25042     } catch (std::exception& e) {
25043       {
25044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25045       };
25046     } catch (...) {
25047       {
25048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25049       };
25050     }
25051   }
25052   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25053   return jresult;
25054 }
25055
25056
25057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25058   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25059   Dali::FrameBufferImage arg2 ;
25060   Dali::FrameBufferImage *argp2 ;
25061
25062   arg1 = (Dali::RenderTask *)jarg1;
25063   argp2 = (Dali::FrameBufferImage *)jarg2;
25064   if (!argp2) {
25065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25066     return ;
25067   }
25068   arg2 = *argp2;
25069   {
25070     try {
25071       (arg1)->SetTargetFrameBuffer(arg2);
25072     } catch (std::out_of_range& e) {
25073       {
25074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25075       };
25076     } catch (std::exception& e) {
25077       {
25078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25079       };
25080     } catch (...) {
25081       {
25082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25083       };
25084     }
25085   }
25086 }
25087
25088
25089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25090   void * jresult ;
25091   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25092   Dali::FrameBufferImage result;
25093
25094   arg1 = (Dali::RenderTask *)jarg1;
25095   {
25096     try {
25097       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25098     } catch (std::out_of_range& e) {
25099       {
25100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25101       };
25102     } catch (std::exception& e) {
25103       {
25104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25105       };
25106     } catch (...) {
25107       {
25108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25109       };
25110     }
25111   }
25112   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25113   return jresult;
25114 }
25115
25116
25117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25118   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25119   Dali::FrameBuffer arg2 ;
25120   Dali::FrameBuffer *argp2 ;
25121
25122   arg1 = (Dali::RenderTask *)jarg1;
25123   argp2 = (Dali::FrameBuffer *)jarg2;
25124   if (!argp2) {
25125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25126     return ;
25127   }
25128   arg2 = *argp2;
25129   {
25130     try {
25131       (arg1)->SetFrameBuffer(arg2);
25132     } catch (std::out_of_range& e) {
25133       {
25134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25135       };
25136     } catch (std::exception& e) {
25137       {
25138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25139       };
25140     } catch (...) {
25141       {
25142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25143       };
25144     }
25145   }
25146 }
25147
25148
25149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25150   void * jresult ;
25151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25152   Dali::FrameBuffer result;
25153
25154   arg1 = (Dali::RenderTask *)jarg1;
25155   {
25156     try {
25157       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25158     } catch (std::out_of_range& e) {
25159       {
25160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25161       };
25162     } catch (std::exception& e) {
25163       {
25164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (...) {
25167       {
25168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25169       };
25170     }
25171   }
25172   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25173   return jresult;
25174 }
25175
25176
25177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25178   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25179   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25180
25181   arg1 = (Dali::RenderTask *)jarg1;
25182   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25183   {
25184     try {
25185       (arg1)->SetScreenToFrameBufferFunction(arg2);
25186     } catch (std::out_of_range& e) {
25187       {
25188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25189       };
25190     } catch (std::exception& e) {
25191       {
25192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25193       };
25194     } catch (...) {
25195       {
25196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25197       };
25198     }
25199   }
25200 }
25201
25202
25203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25204   void * jresult ;
25205   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25206   Dali::RenderTask::ScreenToFrameBufferFunction result;
25207
25208   arg1 = (Dali::RenderTask *)jarg1;
25209   {
25210     try {
25211       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25212     } catch (std::out_of_range& e) {
25213       {
25214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25215       };
25216     } catch (std::exception& e) {
25217       {
25218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25219       };
25220     } catch (...) {
25221       {
25222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25223       };
25224     }
25225   }
25226   jresult = (void *)result;
25227   return jresult;
25228 }
25229
25230
25231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25232   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25233   Dali::Actor arg2 ;
25234   Dali::Actor *argp2 ;
25235
25236   arg1 = (Dali::RenderTask *)jarg1;
25237   argp2 = (Dali::Actor *)jarg2;
25238   if (!argp2) {
25239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25240     return ;
25241   }
25242   arg2 = *argp2;
25243   {
25244     try {
25245       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25246     } catch (std::out_of_range& e) {
25247       {
25248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25249       };
25250     } catch (std::exception& e) {
25251       {
25252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25253       };
25254     } catch (...) {
25255       {
25256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25257       };
25258     }
25259   }
25260 }
25261
25262
25263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25264   void * jresult ;
25265   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25266   Dali::Actor result;
25267
25268   arg1 = (Dali::RenderTask *)jarg1;
25269   {
25270     try {
25271       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25272     } catch (std::out_of_range& e) {
25273       {
25274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25275       };
25276     } catch (std::exception& e) {
25277       {
25278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25279       };
25280     } catch (...) {
25281       {
25282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25283       };
25284     }
25285   }
25286   jresult = new Dali::Actor((const Dali::Actor &)result);
25287   return jresult;
25288 }
25289
25290
25291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25292   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25293   Dali::Vector2 arg2 ;
25294   Dali::Vector2 *argp2 ;
25295
25296   arg1 = (Dali::RenderTask *)jarg1;
25297   argp2 = (Dali::Vector2 *)jarg2;
25298   if (!argp2) {
25299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25300     return ;
25301   }
25302   arg2 = *argp2;
25303   {
25304     try {
25305       (arg1)->SetViewportPosition(arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25313       };
25314     } catch (...) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25317       };
25318     }
25319   }
25320 }
25321
25322
25323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25324   void * jresult ;
25325   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25326   Dali::Vector2 result;
25327
25328   arg1 = (Dali::RenderTask *)jarg1;
25329   {
25330     try {
25331       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25332     } catch (std::out_of_range& e) {
25333       {
25334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25335       };
25336     } catch (std::exception& e) {
25337       {
25338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25339       };
25340     } catch (...) {
25341       {
25342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25343       };
25344     }
25345   }
25346   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25347   return jresult;
25348 }
25349
25350
25351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25352   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25353   Dali::Vector2 arg2 ;
25354   Dali::Vector2 *argp2 ;
25355
25356   arg1 = (Dali::RenderTask *)jarg1;
25357   argp2 = (Dali::Vector2 *)jarg2;
25358   if (!argp2) {
25359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25360     return ;
25361   }
25362   arg2 = *argp2;
25363   {
25364     try {
25365       (arg1)->SetViewportSize(arg2);
25366     } catch (std::out_of_range& e) {
25367       {
25368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25369       };
25370     } catch (std::exception& e) {
25371       {
25372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25373       };
25374     } catch (...) {
25375       {
25376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25377       };
25378     }
25379   }
25380 }
25381
25382
25383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25384   void * jresult ;
25385   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25386   Dali::Vector2 result;
25387
25388   arg1 = (Dali::RenderTask *)jarg1;
25389   {
25390     try {
25391       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25392     } catch (std::out_of_range& e) {
25393       {
25394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25395       };
25396     } catch (std::exception& e) {
25397       {
25398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25399       };
25400     } catch (...) {
25401       {
25402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25403       };
25404     }
25405   }
25406   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25407   return jresult;
25408 }
25409
25410
25411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25412   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25413   Dali::Viewport arg2 ;
25414   Dali::Viewport *argp2 ;
25415
25416   arg1 = (Dali::RenderTask *)jarg1;
25417   argp2 = (Dali::Viewport *)jarg2;
25418   if (!argp2) {
25419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25420     return ;
25421   }
25422   arg2 = *argp2;
25423   {
25424     try {
25425       (arg1)->SetViewport(arg2);
25426     } catch (std::out_of_range& e) {
25427       {
25428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25429       };
25430     } catch (std::exception& e) {
25431       {
25432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25433       };
25434     } catch (...) {
25435       {
25436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25437       };
25438     }
25439   }
25440 }
25441
25442
25443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25444   void * jresult ;
25445   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25446   Dali::Viewport result;
25447
25448   arg1 = (Dali::RenderTask *)jarg1;
25449   {
25450     try {
25451       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25452     } catch (std::out_of_range& e) {
25453       {
25454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (std::exception& e) {
25457       {
25458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25459       };
25460     } catch (...) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25463       };
25464     }
25465   }
25466   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25467   return jresult;
25468 }
25469
25470
25471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25472   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25473   Dali::Vector4 *arg2 = 0 ;
25474
25475   arg1 = (Dali::RenderTask *)jarg1;
25476   arg2 = (Dali::Vector4 *)jarg2;
25477   if (!arg2) {
25478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25479     return ;
25480   }
25481   {
25482     try {
25483       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25484     } catch (std::out_of_range& e) {
25485       {
25486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25487       };
25488     } catch (std::exception& e) {
25489       {
25490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25491       };
25492     } catch (...) {
25493       {
25494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25495       };
25496     }
25497   }
25498 }
25499
25500
25501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25502   void * jresult ;
25503   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25504   Dali::Vector4 result;
25505
25506   arg1 = (Dali::RenderTask *)jarg1;
25507   {
25508     try {
25509       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25510     } catch (std::out_of_range& e) {
25511       {
25512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25513       };
25514     } catch (std::exception& e) {
25515       {
25516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25517       };
25518     } catch (...) {
25519       {
25520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25521       };
25522     }
25523   }
25524   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25525   return jresult;
25526 }
25527
25528
25529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25530   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25531   bool arg2 ;
25532
25533   arg1 = (Dali::RenderTask *)jarg1;
25534   arg2 = jarg2 ? true : false;
25535   {
25536     try {
25537       (arg1)->SetClearEnabled(arg2);
25538     } catch (std::out_of_range& e) {
25539       {
25540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25541       };
25542     } catch (std::exception& e) {
25543       {
25544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25545       };
25546     } catch (...) {
25547       {
25548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25549       };
25550     }
25551   }
25552 }
25553
25554
25555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25556   unsigned int jresult ;
25557   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25558   bool result;
25559
25560   arg1 = (Dali::RenderTask *)jarg1;
25561   {
25562     try {
25563       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25564     } catch (std::out_of_range& e) {
25565       {
25566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25567       };
25568     } catch (std::exception& e) {
25569       {
25570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25571       };
25572     } catch (...) {
25573       {
25574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25575       };
25576     }
25577   }
25578   jresult = result;
25579   return jresult;
25580 }
25581
25582
25583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25584   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25585   bool arg2 ;
25586
25587   arg1 = (Dali::RenderTask *)jarg1;
25588   arg2 = jarg2 ? true : false;
25589   {
25590     try {
25591       (arg1)->SetCullMode(arg2);
25592     } catch (std::out_of_range& e) {
25593       {
25594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25595       };
25596     } catch (std::exception& e) {
25597       {
25598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25599       };
25600     } catch (...) {
25601       {
25602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25603       };
25604     }
25605   }
25606 }
25607
25608
25609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25610   unsigned int jresult ;
25611   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25612   bool result;
25613
25614   arg1 = (Dali::RenderTask *)jarg1;
25615   {
25616     try {
25617       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25618     } catch (std::out_of_range& e) {
25619       {
25620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25621       };
25622     } catch (std::exception& e) {
25623       {
25624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25625       };
25626     } catch (...) {
25627       {
25628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25629       };
25630     }
25631   }
25632   jresult = result;
25633   return jresult;
25634 }
25635
25636
25637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25638   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25639   unsigned int arg2 ;
25640
25641   arg1 = (Dali::RenderTask *)jarg1;
25642   arg2 = (unsigned int)jarg2;
25643   {
25644     try {
25645       (arg1)->SetRefreshRate(arg2);
25646     } catch (std::out_of_range& e) {
25647       {
25648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25649       };
25650     } catch (std::exception& e) {
25651       {
25652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25653       };
25654     } catch (...) {
25655       {
25656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25657       };
25658     }
25659   }
25660 }
25661
25662
25663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25664   unsigned int jresult ;
25665   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25666   unsigned int result;
25667
25668   arg1 = (Dali::RenderTask *)jarg1;
25669   {
25670     try {
25671       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25672     } catch (std::out_of_range& e) {
25673       {
25674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25675       };
25676     } catch (std::exception& e) {
25677       {
25678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25679       };
25680     } catch (...) {
25681       {
25682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25683       };
25684     }
25685   }
25686   jresult = result;
25687   return jresult;
25688 }
25689
25690
25691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25692   unsigned int jresult ;
25693   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25694   Dali::Vector3 *arg2 = 0 ;
25695   float *arg3 = 0 ;
25696   float *arg4 = 0 ;
25697   bool result;
25698
25699   arg1 = (Dali::RenderTask *)jarg1;
25700   arg2 = (Dali::Vector3 *)jarg2;
25701   if (!arg2) {
25702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25703     return 0;
25704   }
25705   arg3 = (float *)jarg3;
25706   arg4 = (float *)jarg4;
25707   {
25708     try {
25709       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25710     } catch (std::out_of_range& e) {
25711       {
25712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25713       };
25714     } catch (std::exception& e) {
25715       {
25716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25717       };
25718     } catch (...) {
25719       {
25720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25721       };
25722     }
25723   }
25724   jresult = result;
25725   return jresult;
25726 }
25727
25728
25729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25730   unsigned int jresult ;
25731   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25732   Dali::Actor arg2 ;
25733   float arg3 ;
25734   float arg4 ;
25735   float *arg5 = 0 ;
25736   float *arg6 = 0 ;
25737   Dali::Actor *argp2 ;
25738   bool result;
25739
25740   arg1 = (Dali::RenderTask *)jarg1;
25741   argp2 = (Dali::Actor *)jarg2;
25742   if (!argp2) {
25743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25744     return 0;
25745   }
25746   arg2 = *argp2;
25747   arg3 = (float)jarg3;
25748   arg4 = (float)jarg4;
25749   arg5 = (float *)jarg5;
25750   arg6 = (float *)jarg6;
25751   {
25752     try {
25753       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25754     } catch (std::out_of_range& e) {
25755       {
25756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25757       };
25758     } catch (std::exception& e) {
25759       {
25760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25761       };
25762     } catch (...) {
25763       {
25764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25765       };
25766     }
25767   }
25768   jresult = result;
25769   return jresult;
25770 }
25771
25772
25773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25774   void * jresult ;
25775   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25776   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25777
25778   arg1 = (Dali::RenderTask *)jarg1;
25779   {
25780     try {
25781       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25782     } catch (std::out_of_range& e) {
25783       {
25784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25785       };
25786     } catch (std::exception& e) {
25787       {
25788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25789       };
25790     } catch (...) {
25791       {
25792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25793       };
25794     }
25795   }
25796   jresult = (void *)result;
25797   return jresult;
25798 }
25799
25800
25801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25802   void * jresult ;
25803   int arg1 ;
25804   Dali::TouchPoint::State arg2 ;
25805   float arg3 ;
25806   float arg4 ;
25807   Dali::TouchPoint *result = 0 ;
25808
25809   arg1 = (int)jarg1;
25810   arg2 = (Dali::TouchPoint::State)jarg2;
25811   arg3 = (float)jarg3;
25812   arg4 = (float)jarg4;
25813   {
25814     try {
25815       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25816     } catch (std::out_of_range& e) {
25817       {
25818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25819       };
25820     } catch (std::exception& e) {
25821       {
25822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25823       };
25824     } catch (...) {
25825       {
25826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25827       };
25828     }
25829   }
25830   jresult = (void *)result;
25831   return jresult;
25832 }
25833
25834
25835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25836   void * jresult ;
25837   int arg1 ;
25838   Dali::TouchPoint::State arg2 ;
25839   float arg3 ;
25840   float arg4 ;
25841   float arg5 ;
25842   float arg6 ;
25843   Dali::TouchPoint *result = 0 ;
25844
25845   arg1 = (int)jarg1;
25846   arg2 = (Dali::TouchPoint::State)jarg2;
25847   arg3 = (float)jarg3;
25848   arg4 = (float)jarg4;
25849   arg5 = (float)jarg5;
25850   arg6 = (float)jarg6;
25851   {
25852     try {
25853       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25854     } catch (std::out_of_range& e) {
25855       {
25856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25857       };
25858     } catch (std::exception& e) {
25859       {
25860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25861       };
25862     } catch (...) {
25863       {
25864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25865       };
25866     }
25867   }
25868   jresult = (void *)result;
25869   return jresult;
25870 }
25871
25872
25873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25874   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25875
25876   arg1 = (Dali::TouchPoint *)jarg1;
25877   {
25878     try {
25879       delete arg1;
25880     } catch (std::out_of_range& e) {
25881       {
25882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25883       };
25884     } catch (std::exception& e) {
25885       {
25886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25887       };
25888     } catch (...) {
25889       {
25890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25891       };
25892     }
25893   }
25894 }
25895
25896
25897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25898   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25899   int arg2 ;
25900
25901   arg1 = (Dali::TouchPoint *)jarg1;
25902   arg2 = (int)jarg2;
25903   if (arg1) (arg1)->deviceId = arg2;
25904 }
25905
25906
25907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25908   int jresult ;
25909   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25910   int result;
25911
25912   arg1 = (Dali::TouchPoint *)jarg1;
25913   result = (int) ((arg1)->deviceId);
25914   jresult = result;
25915   return jresult;
25916 }
25917
25918
25919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25920   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25921   Dali::TouchPoint::State arg2 ;
25922
25923   arg1 = (Dali::TouchPoint *)jarg1;
25924   arg2 = (Dali::TouchPoint::State)jarg2;
25925   if (arg1) (arg1)->state = arg2;
25926 }
25927
25928
25929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25930   int jresult ;
25931   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25932   Dali::TouchPoint::State result;
25933
25934   arg1 = (Dali::TouchPoint *)jarg1;
25935   result = (Dali::TouchPoint::State) ((arg1)->state);
25936   jresult = (int)result;
25937   return jresult;
25938 }
25939
25940
25941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
25942   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25943   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25944
25945   arg1 = (Dali::TouchPoint *)jarg1;
25946   arg2 = (Dali::Actor *)jarg2;
25947   if (arg1) (arg1)->hitActor = *arg2;
25948 }
25949
25950
25951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
25952   void * jresult ;
25953   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25954   Dali::Actor *result = 0 ;
25955
25956   arg1 = (Dali::TouchPoint *)jarg1;
25957   result = (Dali::Actor *)& ((arg1)->hitActor);
25958   jresult = (void *)result;
25959   return jresult;
25960 }
25961
25962
25963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
25964   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25965   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25966
25967   arg1 = (Dali::TouchPoint *)jarg1;
25968   arg2 = (Dali::Vector2 *)jarg2;
25969   if (arg1) (arg1)->local = *arg2;
25970 }
25971
25972
25973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
25974   void * jresult ;
25975   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25976   Dali::Vector2 *result = 0 ;
25977
25978   arg1 = (Dali::TouchPoint *)jarg1;
25979   result = (Dali::Vector2 *)& ((arg1)->local);
25980   jresult = (void *)result;
25981   return jresult;
25982 }
25983
25984
25985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
25986   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25987   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25988
25989   arg1 = (Dali::TouchPoint *)jarg1;
25990   arg2 = (Dali::Vector2 *)jarg2;
25991   if (arg1) (arg1)->screen = *arg2;
25992 }
25993
25994
25995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
25996   void * jresult ;
25997   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25998   Dali::Vector2 *result = 0 ;
25999
26000   arg1 = (Dali::TouchPoint *)jarg1;
26001   result = (Dali::Vector2 *)& ((arg1)->screen);
26002   jresult = (void *)result;
26003   return jresult;
26004 }
26005
26006
26007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26008   void * jresult ;
26009   Dali::TouchData *result = 0 ;
26010
26011   {
26012     try {
26013       result = (Dali::TouchData *)new Dali::TouchData();
26014     } catch (std::out_of_range& e) {
26015       {
26016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26017       };
26018     } catch (std::exception& e) {
26019       {
26020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26021       };
26022     } catch (...) {
26023       {
26024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26025       };
26026     }
26027   }
26028   jresult = (void *)result;
26029   return jresult;
26030 }
26031
26032
26033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26034   void * jresult ;
26035   Dali::TouchData *arg1 = 0 ;
26036   Dali::TouchData *result = 0 ;
26037
26038   arg1 = (Dali::TouchData *)jarg1;
26039   if (!arg1) {
26040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26041     return 0;
26042   }
26043   {
26044     try {
26045       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26046     } catch (std::out_of_range& e) {
26047       {
26048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26049       };
26050     } catch (std::exception& e) {
26051       {
26052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26053       };
26054     } catch (...) {
26055       {
26056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26057       };
26058     }
26059   }
26060   jresult = (void *)result;
26061   return jresult;
26062 }
26063
26064
26065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26066   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26067
26068   arg1 = (Dali::TouchData *)jarg1;
26069   {
26070     try {
26071       delete arg1;
26072     } catch (std::out_of_range& e) {
26073       {
26074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26075       };
26076     } catch (std::exception& e) {
26077       {
26078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26079       };
26080     } catch (...) {
26081       {
26082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26083       };
26084     }
26085   }
26086 }
26087
26088
26089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26090   void * jresult ;
26091   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26092   Dali::TouchData *arg2 = 0 ;
26093   Dali::TouchData *result = 0 ;
26094
26095   arg1 = (Dali::TouchData *)jarg1;
26096   arg2 = (Dali::TouchData *)jarg2;
26097   if (!arg2) {
26098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26099     return 0;
26100   }
26101   {
26102     try {
26103       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26104     } catch (std::out_of_range& e) {
26105       {
26106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26107       };
26108     } catch (std::exception& e) {
26109       {
26110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26111       };
26112     } catch (...) {
26113       {
26114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26115       };
26116     }
26117   }
26118   jresult = (void *)result;
26119   return jresult;
26120 }
26121
26122
26123 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26124   unsigned long jresult ;
26125   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26126   unsigned long result;
26127
26128   arg1 = (Dali::TouchData *)jarg1;
26129   {
26130     try {
26131       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26132     } catch (std::out_of_range& e) {
26133       {
26134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26135       };
26136     } catch (std::exception& e) {
26137       {
26138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26139       };
26140     } catch (...) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26143       };
26144     }
26145   }
26146   jresult = (unsigned long)result;
26147   return jresult;
26148 }
26149
26150
26151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26152   unsigned long jresult ;
26153   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26154   std::size_t result;
26155
26156   arg1 = (Dali::TouchData *)jarg1;
26157   {
26158     try {
26159       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26160     } catch (std::out_of_range& e) {
26161       {
26162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26163       };
26164     } catch (std::exception& e) {
26165       {
26166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26167       };
26168     } catch (...) {
26169       {
26170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26171       };
26172     }
26173   }
26174   jresult = (unsigned long)result;
26175   return jresult;
26176 }
26177
26178
26179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26180   int jresult ;
26181   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26182   std::size_t arg2 ;
26183   int32_t result;
26184
26185   arg1 = (Dali::TouchData *)jarg1;
26186   arg2 = (std::size_t)jarg2;
26187   {
26188     try {
26189       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26190     } catch (std::out_of_range& e) {
26191       {
26192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26193       };
26194     } catch (std::exception& e) {
26195       {
26196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26197       };
26198     } catch (...) {
26199       {
26200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26201       };
26202     }
26203   }
26204   jresult = result;
26205   return jresult;
26206 }
26207
26208
26209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26210   int jresult ;
26211   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26212   std::size_t arg2 ;
26213   Dali::PointState::Type result;
26214
26215   arg1 = (Dali::TouchData *)jarg1;
26216   arg2 = (std::size_t)jarg2;
26217   {
26218     try {
26219       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26220     } catch (std::out_of_range& e) {
26221       {
26222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26223       };
26224     } catch (std::exception& e) {
26225       {
26226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26227       };
26228     } catch (...) {
26229       {
26230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26231       };
26232     }
26233   }
26234   jresult = (int)result;
26235   return jresult;
26236 }
26237
26238
26239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26240   void * jresult ;
26241   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26242   std::size_t arg2 ;
26243   Dali::Actor result;
26244
26245   arg1 = (Dali::TouchData *)jarg1;
26246   arg2 = (std::size_t)jarg2;
26247   {
26248     try {
26249       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26250     } catch (std::out_of_range& e) {
26251       {
26252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26253       };
26254     } catch (std::exception& e) {
26255       {
26256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26257       };
26258     } catch (...) {
26259       {
26260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26261       };
26262     }
26263   }
26264   jresult = new Dali::Actor((const Dali::Actor &)result);
26265   return jresult;
26266 }
26267
26268
26269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26270   void * jresult ;
26271   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26272   std::size_t arg2 ;
26273   Dali::Vector2 *result = 0 ;
26274
26275   arg1 = (Dali::TouchData *)jarg1;
26276   arg2 = (std::size_t)jarg2;
26277   {
26278     try {
26279       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26280     } catch (std::out_of_range& e) {
26281       {
26282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26283       };
26284     } catch (std::exception& e) {
26285       {
26286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26287       };
26288     } catch (...) {
26289       {
26290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26291       };
26292     }
26293   }
26294   jresult = (void *)result;
26295   return jresult;
26296 }
26297
26298
26299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26300   void * jresult ;
26301   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26302   std::size_t arg2 ;
26303   Dali::Vector2 *result = 0 ;
26304
26305   arg1 = (Dali::TouchData *)jarg1;
26306   arg2 = (std::size_t)jarg2;
26307   {
26308     try {
26309       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26310     } catch (std::out_of_range& e) {
26311       {
26312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26313       };
26314     } catch (std::exception& e) {
26315       {
26316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26317       };
26318     } catch (...) {
26319       {
26320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26321       };
26322     }
26323   }
26324   jresult = (void *)result;
26325   return jresult;
26326 }
26327
26328
26329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26330   float jresult ;
26331   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26332   std::size_t arg2 ;
26333   float result;
26334
26335   arg1 = (Dali::TouchData *)jarg1;
26336   arg2 = (std::size_t)jarg2;
26337   {
26338     try {
26339       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26340     } catch (std::out_of_range& e) {
26341       {
26342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26343       };
26344     } catch (std::exception& e) {
26345       {
26346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26347       };
26348     } catch (...) {
26349       {
26350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26351       };
26352     }
26353   }
26354   jresult = result;
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26360   void * jresult ;
26361   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26362   std::size_t arg2 ;
26363   Dali::Vector2 *result = 0 ;
26364
26365   arg1 = (Dali::TouchData *)jarg1;
26366   arg2 = (std::size_t)jarg2;
26367   {
26368     try {
26369       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26370     } catch (std::out_of_range& e) {
26371       {
26372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26373       };
26374     } catch (std::exception& e) {
26375       {
26376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26377       };
26378     } catch (...) {
26379       {
26380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26381       };
26382     }
26383   }
26384   jresult = (void *)result;
26385   return jresult;
26386 }
26387
26388
26389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26390   float jresult ;
26391   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26392   std::size_t arg2 ;
26393   float result;
26394
26395   arg1 = (Dali::TouchData *)jarg1;
26396   arg2 = (std::size_t)jarg2;
26397   {
26398     try {
26399       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26400     } catch (std::out_of_range& e) {
26401       {
26402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26403       };
26404     } catch (std::exception& e) {
26405       {
26406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26407       };
26408     } catch (...) {
26409       {
26410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26411       };
26412     }
26413   }
26414   jresult = result;
26415   return jresult;
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26420   void * jresult ;
26421   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26422   std::size_t arg2 ;
26423   Dali::Degree result;
26424
26425   arg1 = (Dali::TouchData *)jarg1;
26426   arg2 = (std::size_t)jarg2;
26427   {
26428     try {
26429       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26430     } catch (std::out_of_range& e) {
26431       {
26432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26433       };
26434     } catch (std::exception& e) {
26435       {
26436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26437       };
26438     } catch (...) {
26439       {
26440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26441       };
26442     }
26443   }
26444   jresult = new Dali::Degree((const Dali::Degree &)result);
26445   return jresult;
26446 }
26447
26448
26449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26450   void * jresult ;
26451   Dali::GestureDetector *result = 0 ;
26452
26453   {
26454     try {
26455       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26456     } catch (std::out_of_range& e) {
26457       {
26458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26459       };
26460     } catch (std::exception& e) {
26461       {
26462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26463       };
26464     } catch (...) {
26465       {
26466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26467       };
26468     }
26469   }
26470   jresult = (void *)result;
26471   return jresult;
26472 }
26473
26474
26475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26476   void * jresult ;
26477   Dali::BaseHandle arg1 ;
26478   Dali::BaseHandle *argp1 ;
26479   Dali::GestureDetector result;
26480
26481   argp1 = (Dali::BaseHandle *)jarg1;
26482   if (!argp1) {
26483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26484     return 0;
26485   }
26486   arg1 = *argp1;
26487   {
26488     try {
26489       result = Dali::GestureDetector::DownCast(arg1);
26490     } catch (std::out_of_range& e) {
26491       {
26492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26493       };
26494     } catch (std::exception& e) {
26495       {
26496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26497       };
26498     } catch (...) {
26499       {
26500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26501       };
26502     }
26503   }
26504   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26505   return jresult;
26506 }
26507
26508
26509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26510   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26511
26512   arg1 = (Dali::GestureDetector *)jarg1;
26513   {
26514     try {
26515       delete arg1;
26516     } catch (std::out_of_range& e) {
26517       {
26518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26519       };
26520     } catch (std::exception& e) {
26521       {
26522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26523       };
26524     } catch (...) {
26525       {
26526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26527       };
26528     }
26529   }
26530 }
26531
26532
26533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26534   void * jresult ;
26535   Dali::GestureDetector *arg1 = 0 ;
26536   Dali::GestureDetector *result = 0 ;
26537
26538   arg1 = (Dali::GestureDetector *)jarg1;
26539   if (!arg1) {
26540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26541     return 0;
26542   }
26543   {
26544     try {
26545       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26546     } catch (std::out_of_range& e) {
26547       {
26548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26549       };
26550     } catch (std::exception& e) {
26551       {
26552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26553       };
26554     } catch (...) {
26555       {
26556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26557       };
26558     }
26559   }
26560   jresult = (void *)result;
26561   return jresult;
26562 }
26563
26564
26565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26566   void * jresult ;
26567   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26568   Dali::GestureDetector *arg2 = 0 ;
26569   Dali::GestureDetector *result = 0 ;
26570
26571   arg1 = (Dali::GestureDetector *)jarg1;
26572   arg2 = (Dali::GestureDetector *)jarg2;
26573   if (!arg2) {
26574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26575     return 0;
26576   }
26577   {
26578     try {
26579       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26580     } catch (std::out_of_range& e) {
26581       {
26582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26583       };
26584     } catch (std::exception& e) {
26585       {
26586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26587       };
26588     } catch (...) {
26589       {
26590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26591       };
26592     }
26593   }
26594   jresult = (void *)result;
26595   return jresult;
26596 }
26597
26598
26599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26600   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26601   Dali::Actor arg2 ;
26602   Dali::Actor *argp2 ;
26603
26604   arg1 = (Dali::GestureDetector *)jarg1;
26605   argp2 = (Dali::Actor *)jarg2;
26606   if (!argp2) {
26607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26608     return ;
26609   }
26610   arg2 = *argp2;
26611   {
26612     try {
26613       (arg1)->Attach(arg2);
26614     } catch (std::out_of_range& e) {
26615       {
26616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26617       };
26618     } catch (std::exception& e) {
26619       {
26620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26621       };
26622     } catch (...) {
26623       {
26624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26625       };
26626     }
26627   }
26628 }
26629
26630
26631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26632   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26633   Dali::Actor arg2 ;
26634   Dali::Actor *argp2 ;
26635
26636   arg1 = (Dali::GestureDetector *)jarg1;
26637   argp2 = (Dali::Actor *)jarg2;
26638   if (!argp2) {
26639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26640     return ;
26641   }
26642   arg2 = *argp2;
26643   {
26644     try {
26645       (arg1)->Detach(arg2);
26646     } catch (std::out_of_range& e) {
26647       {
26648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26649       };
26650     } catch (std::exception& e) {
26651       {
26652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26653       };
26654     } catch (...) {
26655       {
26656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26657       };
26658     }
26659   }
26660 }
26661
26662
26663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26664   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26665
26666   arg1 = (Dali::GestureDetector *)jarg1;
26667   {
26668     try {
26669       (arg1)->DetachAll();
26670     } catch (std::out_of_range& e) {
26671       {
26672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26673       };
26674     } catch (std::exception& e) {
26675       {
26676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26677       };
26678     } catch (...) {
26679       {
26680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26681       };
26682     }
26683   }
26684 }
26685
26686
26687 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26688   unsigned long jresult ;
26689   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26690   size_t result;
26691
26692   arg1 = (Dali::GestureDetector *)jarg1;
26693   {
26694     try {
26695       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26696     } catch (std::out_of_range& e) {
26697       {
26698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26699       };
26700     } catch (std::exception& e) {
26701       {
26702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26703       };
26704     } catch (...) {
26705       {
26706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26707       };
26708     }
26709   }
26710   jresult = (unsigned long)result;
26711   return jresult;
26712 }
26713
26714
26715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26716   void * jresult ;
26717   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26718   size_t arg2 ;
26719   Dali::Actor result;
26720
26721   arg1 = (Dali::GestureDetector *)jarg1;
26722   arg2 = (size_t)jarg2;
26723   {
26724     try {
26725       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26726     } catch (std::out_of_range& e) {
26727       {
26728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26729       };
26730     } catch (std::exception& e) {
26731       {
26732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26733       };
26734     } catch (...) {
26735       {
26736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26737       };
26738     }
26739   }
26740   jresult = new Dali::Actor((const Dali::Actor &)result);
26741   return jresult;
26742 }
26743
26744
26745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26746   void * jresult ;
26747   Dali::Gesture *arg1 = 0 ;
26748   Dali::Gesture *result = 0 ;
26749
26750   arg1 = (Dali::Gesture *)jarg1;
26751   if (!arg1) {
26752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26753     return 0;
26754   }
26755   {
26756     try {
26757       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26758     } catch (std::out_of_range& e) {
26759       {
26760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26761       };
26762     } catch (std::exception& e) {
26763       {
26764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26765       };
26766     } catch (...) {
26767       {
26768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26769       };
26770     }
26771   }
26772   jresult = (void *)result;
26773   return jresult;
26774 }
26775
26776
26777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26778   void * jresult ;
26779   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26780   Dali::Gesture *arg2 = 0 ;
26781   Dali::Gesture *result = 0 ;
26782
26783   arg1 = (Dali::Gesture *)jarg1;
26784   arg2 = (Dali::Gesture *)jarg2;
26785   if (!arg2) {
26786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26787     return 0;
26788   }
26789   {
26790     try {
26791       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26792     } catch (std::out_of_range& e) {
26793       {
26794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26795       };
26796     } catch (std::exception& e) {
26797       {
26798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26799       };
26800     } catch (...) {
26801       {
26802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26803       };
26804     }
26805   }
26806   jresult = (void *)result;
26807   return jresult;
26808 }
26809
26810
26811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26812   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26813
26814   arg1 = (Dali::Gesture *)jarg1;
26815   {
26816     try {
26817       delete arg1;
26818     } catch (std::out_of_range& e) {
26819       {
26820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26821       };
26822     } catch (std::exception& e) {
26823       {
26824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26825       };
26826     } catch (...) {
26827       {
26828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26829       };
26830     }
26831   }
26832 }
26833
26834
26835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26836   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26837   Dali::Gesture::Type arg2 ;
26838
26839   arg1 = (Dali::Gesture *)jarg1;
26840   arg2 = (Dali::Gesture::Type)jarg2;
26841   if (arg1) (arg1)->type = arg2;
26842 }
26843
26844
26845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26846   int jresult ;
26847   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26848   Dali::Gesture::Type result;
26849
26850   arg1 = (Dali::Gesture *)jarg1;
26851   result = (Dali::Gesture::Type) ((arg1)->type);
26852   jresult = (int)result;
26853   return jresult;
26854 }
26855
26856
26857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26858   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26859   Dali::Gesture::State arg2 ;
26860
26861   arg1 = (Dali::Gesture *)jarg1;
26862   arg2 = (Dali::Gesture::State)jarg2;
26863   if (arg1) (arg1)->state = arg2;
26864 }
26865
26866
26867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26868   int jresult ;
26869   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26870   Dali::Gesture::State result;
26871
26872   arg1 = (Dali::Gesture *)jarg1;
26873   result = (Dali::Gesture::State) ((arg1)->state);
26874   jresult = (int)result;
26875   return jresult;
26876 }
26877
26878
26879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26880   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26881   unsigned int arg2 ;
26882
26883   arg1 = (Dali::Gesture *)jarg1;
26884   arg2 = (unsigned int)jarg2;
26885   if (arg1) (arg1)->time = arg2;
26886 }
26887
26888
26889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26890   unsigned int jresult ;
26891   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26892   unsigned int result;
26893
26894   arg1 = (Dali::Gesture *)jarg1;
26895   result = (unsigned int) ((arg1)->time);
26896   jresult = result;
26897   return jresult;
26898 }
26899
26900
26901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26902   void * jresult ;
26903   Dali::HoverEvent *result = 0 ;
26904
26905   {
26906     try {
26907       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26908     } catch (std::out_of_range& e) {
26909       {
26910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26911       };
26912     } catch (std::exception& e) {
26913       {
26914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26915       };
26916     } catch (...) {
26917       {
26918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26919       };
26920     }
26921   }
26922   jresult = (void *)result;
26923   return jresult;
26924 }
26925
26926
26927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26928   void * jresult ;
26929   unsigned long arg1 ;
26930   Dali::HoverEvent *result = 0 ;
26931
26932   arg1 = (unsigned long)jarg1;
26933   {
26934     try {
26935       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26936     } catch (std::out_of_range& e) {
26937       {
26938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26939       };
26940     } catch (std::exception& e) {
26941       {
26942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26943       };
26944     } catch (...) {
26945       {
26946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26947       };
26948     }
26949   }
26950   jresult = (void *)result;
26951   return jresult;
26952 }
26953
26954
26955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
26956   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26957
26958   arg1 = (Dali::HoverEvent *)jarg1;
26959   {
26960     try {
26961       delete arg1;
26962     } catch (std::out_of_range& e) {
26963       {
26964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26965       };
26966     } catch (std::exception& e) {
26967       {
26968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26969       };
26970     } catch (...) {
26971       {
26972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26973       };
26974     }
26975   }
26976 }
26977
26978
26979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
26980   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26981   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
26982
26983   arg1 = (Dali::HoverEvent *)jarg1;
26984   arg2 = (Dali::TouchPointContainer *)jarg2;
26985   if (arg1) (arg1)->points = *arg2;
26986 }
26987
26988
26989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
26990   void * jresult ;
26991   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26992   Dali::TouchPointContainer *result = 0 ;
26993
26994   arg1 = (Dali::HoverEvent *)jarg1;
26995   result = (Dali::TouchPointContainer *)& ((arg1)->points);
26996   jresult = (void *)result;
26997   return jresult;
26998 }
26999
27000
27001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27002   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27003   unsigned long arg2 ;
27004
27005   arg1 = (Dali::HoverEvent *)jarg1;
27006   arg2 = (unsigned long)jarg2;
27007   if (arg1) (arg1)->time = arg2;
27008 }
27009
27010
27011 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27012   unsigned long jresult ;
27013   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27014   unsigned long result;
27015
27016   arg1 = (Dali::HoverEvent *)jarg1;
27017   result = (unsigned long) ((arg1)->time);
27018   jresult = (unsigned long)result;
27019   return jresult;
27020 }
27021
27022
27023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27024   unsigned int jresult ;
27025   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27026   unsigned int result;
27027
27028   arg1 = (Dali::HoverEvent *)jarg1;
27029   {
27030     try {
27031       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27032     } catch (std::out_of_range& e) {
27033       {
27034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27035       };
27036     } catch (std::exception& e) {
27037       {
27038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27039       };
27040     } catch (...) {
27041       {
27042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27043       };
27044     }
27045   }
27046   jresult = result;
27047   return jresult;
27048 }
27049
27050
27051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27052   void * jresult ;
27053   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27054   unsigned int arg2 ;
27055   Dali::TouchPoint *result = 0 ;
27056
27057   arg1 = (Dali::HoverEvent *)jarg1;
27058   arg2 = (unsigned int)jarg2;
27059   {
27060     try {
27061       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27062     } catch (std::out_of_range& e) {
27063       {
27064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27065       };
27066     } catch (std::exception& e) {
27067       {
27068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27069       };
27070     } catch (...) {
27071       {
27072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27073       };
27074     }
27075   }
27076   jresult = (void *)result;
27077   return jresult;
27078 }
27079
27080
27081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27082   void * jresult ;
27083   Dali::KeyEvent *result = 0 ;
27084
27085   {
27086     try {
27087       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27088     } catch (std::out_of_range& e) {
27089       {
27090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27091       };
27092     } catch (std::exception& e) {
27093       {
27094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (...) {
27097       {
27098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27099       };
27100     }
27101   }
27102   jresult = (void *)result;
27103   return jresult;
27104 }
27105
27106
27107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27108   void * jresult ;
27109   std::string *arg1 = 0 ;
27110   std::string *arg2 = 0 ;
27111   int arg3 ;
27112   int arg4 ;
27113   unsigned long arg5 ;
27114   Dali::KeyEvent::State *arg6 = 0 ;
27115   Dali::KeyEvent::State temp6 ;
27116   Dali::KeyEvent *result = 0 ;
27117
27118   if (!jarg1) {
27119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27120     return 0;
27121   }
27122   std::string arg1_str(jarg1);
27123   arg1 = &arg1_str;
27124   if (!jarg2) {
27125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27126     return 0;
27127   }
27128   std::string arg2_str(jarg2);
27129   arg2 = &arg2_str;
27130   arg3 = (int)jarg3;
27131   arg4 = (int)jarg4;
27132   arg5 = (unsigned long)jarg5;
27133   temp6 = (Dali::KeyEvent::State)jarg6;
27134   arg6 = &temp6;
27135   {
27136     try {
27137       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27138     } catch (std::out_of_range& e) {
27139       {
27140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27141       };
27142     } catch (std::exception& e) {
27143       {
27144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27145       };
27146     } catch (...) {
27147       {
27148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27149       };
27150     }
27151   }
27152   jresult = (void *)result;
27153
27154   //argout typemap for const std::string&
27155
27156
27157   //argout typemap for const std::string&
27158
27159   return jresult;
27160 }
27161
27162
27163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27164   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27165
27166   arg1 = (Dali::KeyEvent *)jarg1;
27167   {
27168     try {
27169       delete arg1;
27170     } catch (std::out_of_range& e) {
27171       {
27172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27173       };
27174     } catch (std::exception& e) {
27175       {
27176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27177       };
27178     } catch (...) {
27179       {
27180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27181       };
27182     }
27183   }
27184 }
27185
27186
27187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27188   unsigned int jresult ;
27189   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27190   bool result;
27191
27192   arg1 = (Dali::KeyEvent *)jarg1;
27193   {
27194     try {
27195       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27196     } catch (std::out_of_range& e) {
27197       {
27198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27199       };
27200     } catch (std::exception& e) {
27201       {
27202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27203       };
27204     } catch (...) {
27205       {
27206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27207       };
27208     }
27209   }
27210   jresult = result;
27211   return jresult;
27212 }
27213
27214
27215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27216   unsigned int jresult ;
27217   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27218   bool result;
27219
27220   arg1 = (Dali::KeyEvent *)jarg1;
27221   {
27222     try {
27223       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27224     } catch (std::out_of_range& e) {
27225       {
27226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27227       };
27228     } catch (std::exception& e) {
27229       {
27230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27231       };
27232     } catch (...) {
27233       {
27234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27235       };
27236     }
27237   }
27238   jresult = result;
27239   return jresult;
27240 }
27241
27242
27243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27244   unsigned int jresult ;
27245   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27246   bool result;
27247
27248   arg1 = (Dali::KeyEvent *)jarg1;
27249   {
27250     try {
27251       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27252     } catch (std::out_of_range& e) {
27253       {
27254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27255       };
27256     } catch (std::exception& e) {
27257       {
27258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27259       };
27260     } catch (...) {
27261       {
27262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27263       };
27264     }
27265   }
27266   jresult = result;
27267   return jresult;
27268 }
27269
27270
27271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27272   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27273   std::string *arg2 = 0 ;
27274
27275   arg1 = (Dali::KeyEvent *)jarg1;
27276   if (!jarg2) {
27277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27278     return ;
27279   }
27280   std::string arg2_str(jarg2);
27281   arg2 = &arg2_str;
27282   if (arg1) (arg1)->keyPressedName = *arg2;
27283
27284   //argout typemap for const std::string&
27285
27286 }
27287
27288
27289 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27290   char * jresult ;
27291   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27292   std::string *result = 0 ;
27293
27294   arg1 = (Dali::KeyEvent *)jarg1;
27295   result = (std::string *) & ((arg1)->keyPressedName);
27296   jresult = SWIG_csharp_string_callback(result->c_str());
27297   return jresult;
27298 }
27299
27300
27301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27302   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27303   std::string *arg2 = 0 ;
27304
27305   arg1 = (Dali::KeyEvent *)jarg1;
27306   if (!jarg2) {
27307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27308     return ;
27309   }
27310   std::string arg2_str(jarg2);
27311   arg2 = &arg2_str;
27312   if (arg1) (arg1)->keyPressed = *arg2;
27313
27314   //argout typemap for const std::string&
27315
27316 }
27317
27318
27319 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27320   char * jresult ;
27321   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27322   std::string *result = 0 ;
27323
27324   arg1 = (Dali::KeyEvent *)jarg1;
27325   result = (std::string *) & ((arg1)->keyPressed);
27326   jresult = SWIG_csharp_string_callback(result->c_str());
27327   return jresult;
27328 }
27329
27330
27331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27332   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27333   int arg2 ;
27334
27335   arg1 = (Dali::KeyEvent *)jarg1;
27336   arg2 = (int)jarg2;
27337   if (arg1) (arg1)->keyCode = arg2;
27338 }
27339
27340
27341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27342   int jresult ;
27343   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27344   int result;
27345
27346   arg1 = (Dali::KeyEvent *)jarg1;
27347   result = (int) ((arg1)->keyCode);
27348   jresult = result;
27349   return jresult;
27350 }
27351
27352
27353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27354   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27355   int arg2 ;
27356
27357   arg1 = (Dali::KeyEvent *)jarg1;
27358   arg2 = (int)jarg2;
27359   if (arg1) (arg1)->keyModifier = arg2;
27360 }
27361
27362
27363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27364   int jresult ;
27365   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27366   int result;
27367
27368   arg1 = (Dali::KeyEvent *)jarg1;
27369   result = (int) ((arg1)->keyModifier);
27370   jresult = result;
27371   return jresult;
27372 }
27373
27374
27375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27376   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27377   unsigned long arg2 ;
27378
27379   arg1 = (Dali::KeyEvent *)jarg1;
27380   arg2 = (unsigned long)jarg2;
27381   if (arg1) (arg1)->time = arg2;
27382 }
27383
27384
27385 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27386   unsigned long jresult ;
27387   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27388   unsigned long result;
27389
27390   arg1 = (Dali::KeyEvent *)jarg1;
27391   result = (unsigned long) ((arg1)->time);
27392   jresult = (unsigned long)result;
27393   return jresult;
27394 }
27395
27396
27397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27398   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27399   Dali::KeyEvent::State arg2 ;
27400
27401   arg1 = (Dali::KeyEvent *)jarg1;
27402   arg2 = (Dali::KeyEvent::State)jarg2;
27403   if (arg1) (arg1)->state = arg2;
27404 }
27405
27406
27407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27408   int jresult ;
27409   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27410   Dali::KeyEvent::State result;
27411
27412   arg1 = (Dali::KeyEvent *)jarg1;
27413   result = (Dali::KeyEvent::State) ((arg1)->state);
27414   jresult = (int)result;
27415   return jresult;
27416 }
27417
27418
27419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27420   void * jresult ;
27421   Dali::LongPressGestureDetector *result = 0 ;
27422
27423   {
27424     try {
27425       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27426     } catch (std::out_of_range& e) {
27427       {
27428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27429       };
27430     } catch (std::exception& e) {
27431       {
27432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27433       };
27434     } catch (...) {
27435       {
27436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27437       };
27438     }
27439   }
27440   jresult = (void *)result;
27441   return jresult;
27442 }
27443
27444
27445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27446   void * jresult ;
27447   Dali::LongPressGestureDetector result;
27448
27449   {
27450     try {
27451       result = Dali::LongPressGestureDetector::New();
27452     } catch (std::out_of_range& e) {
27453       {
27454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27455       };
27456     } catch (std::exception& e) {
27457       {
27458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27459       };
27460     } catch (...) {
27461       {
27462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27463       };
27464     }
27465   }
27466   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27467   return jresult;
27468 }
27469
27470
27471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27472   void * jresult ;
27473   unsigned int arg1 ;
27474   Dali::LongPressGestureDetector result;
27475
27476   arg1 = (unsigned int)jarg1;
27477   {
27478     try {
27479       result = Dali::LongPressGestureDetector::New(arg1);
27480     } catch (std::out_of_range& e) {
27481       {
27482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27483       };
27484     } catch (std::exception& e) {
27485       {
27486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27487       };
27488     } catch (...) {
27489       {
27490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27491       };
27492     }
27493   }
27494   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27495   return jresult;
27496 }
27497
27498
27499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27500   void * jresult ;
27501   unsigned int arg1 ;
27502   unsigned int arg2 ;
27503   Dali::LongPressGestureDetector result;
27504
27505   arg1 = (unsigned int)jarg1;
27506   arg2 = (unsigned int)jarg2;
27507   {
27508     try {
27509       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27510     } catch (std::out_of_range& e) {
27511       {
27512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27513       };
27514     } catch (std::exception& e) {
27515       {
27516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27517       };
27518     } catch (...) {
27519       {
27520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27521       };
27522     }
27523   }
27524   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27525   return jresult;
27526 }
27527
27528
27529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27530   void * jresult ;
27531   Dali::BaseHandle arg1 ;
27532   Dali::BaseHandle *argp1 ;
27533   Dali::LongPressGestureDetector result;
27534
27535   argp1 = (Dali::BaseHandle *)jarg1;
27536   if (!argp1) {
27537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27538     return 0;
27539   }
27540   arg1 = *argp1;
27541   {
27542     try {
27543       result = Dali::LongPressGestureDetector::DownCast(arg1);
27544     } catch (std::out_of_range& e) {
27545       {
27546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27547       };
27548     } catch (std::exception& e) {
27549       {
27550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27551       };
27552     } catch (...) {
27553       {
27554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27555       };
27556     }
27557   }
27558   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27559   return jresult;
27560 }
27561
27562
27563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27564   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27565
27566   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27567   {
27568     try {
27569       delete arg1;
27570     } catch (std::out_of_range& e) {
27571       {
27572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27573       };
27574     } catch (std::exception& e) {
27575       {
27576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27577       };
27578     } catch (...) {
27579       {
27580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27581       };
27582     }
27583   }
27584 }
27585
27586
27587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27588   void * jresult ;
27589   Dali::LongPressGestureDetector *arg1 = 0 ;
27590   Dali::LongPressGestureDetector *result = 0 ;
27591
27592   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27593   if (!arg1) {
27594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27595     return 0;
27596   }
27597   {
27598     try {
27599       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27600     } catch (std::out_of_range& e) {
27601       {
27602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27603       };
27604     } catch (std::exception& e) {
27605       {
27606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27607       };
27608     } catch (...) {
27609       {
27610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27611       };
27612     }
27613   }
27614   jresult = (void *)result;
27615   return jresult;
27616 }
27617
27618
27619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27620   void * jresult ;
27621   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27622   Dali::LongPressGestureDetector *arg2 = 0 ;
27623   Dali::LongPressGestureDetector *result = 0 ;
27624
27625   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27626   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27627   if (!arg2) {
27628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27629     return 0;
27630   }
27631   {
27632     try {
27633       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27634     } catch (std::out_of_range& e) {
27635       {
27636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27637       };
27638     } catch (std::exception& e) {
27639       {
27640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27641       };
27642     } catch (...) {
27643       {
27644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27645       };
27646     }
27647   }
27648   jresult = (void *)result;
27649   return jresult;
27650 }
27651
27652
27653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27654   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27655   unsigned int arg2 ;
27656
27657   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27658   arg2 = (unsigned int)jarg2;
27659   {
27660     try {
27661       (arg1)->SetTouchesRequired(arg2);
27662     } catch (std::out_of_range& e) {
27663       {
27664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27665       };
27666     } catch (std::exception& e) {
27667       {
27668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27669       };
27670     } catch (...) {
27671       {
27672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27673       };
27674     }
27675   }
27676 }
27677
27678
27679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27680   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27681   unsigned int arg2 ;
27682   unsigned int arg3 ;
27683
27684   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27685   arg2 = (unsigned int)jarg2;
27686   arg3 = (unsigned int)jarg3;
27687   {
27688     try {
27689       (arg1)->SetTouchesRequired(arg2,arg3);
27690     } catch (std::out_of_range& e) {
27691       {
27692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27693       };
27694     } catch (std::exception& e) {
27695       {
27696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27697       };
27698     } catch (...) {
27699       {
27700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27701       };
27702     }
27703   }
27704 }
27705
27706
27707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27708   unsigned int jresult ;
27709   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27710   unsigned int result;
27711
27712   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27713   {
27714     try {
27715       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27716     } catch (std::out_of_range& e) {
27717       {
27718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27719       };
27720     } catch (std::exception& e) {
27721       {
27722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27723       };
27724     } catch (...) {
27725       {
27726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27727       };
27728     }
27729   }
27730   jresult = result;
27731   return jresult;
27732 }
27733
27734
27735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27736   unsigned int jresult ;
27737   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27738   unsigned int result;
27739
27740   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27741   {
27742     try {
27743       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27744     } catch (std::out_of_range& e) {
27745       {
27746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27747       };
27748     } catch (std::exception& e) {
27749       {
27750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27751       };
27752     } catch (...) {
27753       {
27754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27755       };
27756     }
27757   }
27758   jresult = result;
27759   return jresult;
27760 }
27761
27762
27763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27764   void * jresult ;
27765   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27766   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27767
27768   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27769   {
27770     try {
27771       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27772     } catch (std::out_of_range& e) {
27773       {
27774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27775       };
27776     } catch (std::exception& e) {
27777       {
27778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27779       };
27780     } catch (...) {
27781       {
27782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27783       };
27784     }
27785   }
27786   jresult = (void *)result;
27787   return jresult;
27788 }
27789
27790
27791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27792   void * jresult ;
27793   Dali::Gesture::State arg1 ;
27794   Dali::LongPressGesture *result = 0 ;
27795
27796   arg1 = (Dali::Gesture::State)jarg1;
27797   {
27798     try {
27799       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27800     } catch (std::out_of_range& e) {
27801       {
27802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27803       };
27804     } catch (std::exception& e) {
27805       {
27806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27807       };
27808     } catch (...) {
27809       {
27810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27811       };
27812     }
27813   }
27814   jresult = (void *)result;
27815   return jresult;
27816 }
27817
27818
27819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27820   void * jresult ;
27821   Dali::LongPressGesture *arg1 = 0 ;
27822   Dali::LongPressGesture *result = 0 ;
27823
27824   arg1 = (Dali::LongPressGesture *)jarg1;
27825   if (!arg1) {
27826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27827     return 0;
27828   }
27829   {
27830     try {
27831       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27832     } catch (std::out_of_range& e) {
27833       {
27834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27835       };
27836     } catch (std::exception& e) {
27837       {
27838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27839       };
27840     } catch (...) {
27841       {
27842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27843       };
27844     }
27845   }
27846   jresult = (void *)result;
27847   return jresult;
27848 }
27849
27850
27851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27852   void * jresult ;
27853   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27854   Dali::LongPressGesture *arg2 = 0 ;
27855   Dali::LongPressGesture *result = 0 ;
27856
27857   arg1 = (Dali::LongPressGesture *)jarg1;
27858   arg2 = (Dali::LongPressGesture *)jarg2;
27859   if (!arg2) {
27860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27861     return 0;
27862   }
27863   {
27864     try {
27865       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27866     } catch (std::out_of_range& e) {
27867       {
27868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27869       };
27870     } catch (std::exception& e) {
27871       {
27872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27873       };
27874     } catch (...) {
27875       {
27876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27877       };
27878     }
27879   }
27880   jresult = (void *)result;
27881   return jresult;
27882 }
27883
27884
27885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
27886   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27887
27888   arg1 = (Dali::LongPressGesture *)jarg1;
27889   {
27890     try {
27891       delete arg1;
27892     } catch (std::out_of_range& e) {
27893       {
27894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27895       };
27896     } catch (std::exception& e) {
27897       {
27898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27899       };
27900     } catch (...) {
27901       {
27902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27903       };
27904     }
27905   }
27906 }
27907
27908
27909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
27910   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27911   unsigned int arg2 ;
27912
27913   arg1 = (Dali::LongPressGesture *)jarg1;
27914   arg2 = (unsigned int)jarg2;
27915   if (arg1) (arg1)->numberOfTouches = arg2;
27916 }
27917
27918
27919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
27920   unsigned int jresult ;
27921   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27922   unsigned int result;
27923
27924   arg1 = (Dali::LongPressGesture *)jarg1;
27925   result = (unsigned int) ((arg1)->numberOfTouches);
27926   jresult = result;
27927   return jresult;
27928 }
27929
27930
27931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
27932   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27933   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
27934
27935   arg1 = (Dali::LongPressGesture *)jarg1;
27936   arg2 = (Dali::Vector2 *)jarg2;
27937   if (arg1) (arg1)->screenPoint = *arg2;
27938 }
27939
27940
27941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
27942   void * jresult ;
27943   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27944   Dali::Vector2 *result = 0 ;
27945
27946   arg1 = (Dali::LongPressGesture *)jarg1;
27947   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
27948   jresult = (void *)result;
27949   return jresult;
27950 }
27951
27952
27953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
27954   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27955   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
27956
27957   arg1 = (Dali::LongPressGesture *)jarg1;
27958   arg2 = (Dali::Vector2 *)jarg2;
27959   if (arg1) (arg1)->localPoint = *arg2;
27960 }
27961
27962
27963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
27964   void * jresult ;
27965   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27966   Dali::Vector2 *result = 0 ;
27967
27968   arg1 = (Dali::LongPressGesture *)jarg1;
27969   result = (Dali::Vector2 *)& ((arg1)->localPoint);
27970   jresult = (void *)result;
27971   return jresult;
27972 }
27973
27974
27975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
27976   void * jresult ;
27977   Dali::WheelEvent *result = 0 ;
27978
27979   {
27980     try {
27981       result = (Dali::WheelEvent *)new Dali::WheelEvent();
27982     } catch (std::out_of_range& e) {
27983       {
27984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27985       };
27986     } catch (std::exception& e) {
27987       {
27988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27989       };
27990     } catch (...) {
27991       {
27992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27993       };
27994     }
27995   }
27996   jresult = (void *)result;
27997   return jresult;
27998 }
27999
28000
28001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28002   void * jresult ;
28003   Dali::WheelEvent::Type arg1 ;
28004   int arg2 ;
28005   unsigned int arg3 ;
28006   Dali::Vector2 arg4 ;
28007   int arg5 ;
28008   unsigned int arg6 ;
28009   Dali::Vector2 *argp4 ;
28010   Dali::WheelEvent *result = 0 ;
28011
28012   arg1 = (Dali::WheelEvent::Type)jarg1;
28013   arg2 = (int)jarg2;
28014   arg3 = (unsigned int)jarg3;
28015   argp4 = (Dali::Vector2 *)jarg4;
28016   if (!argp4) {
28017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28018     return 0;
28019   }
28020   arg4 = *argp4;
28021   arg5 = (int)jarg5;
28022   arg6 = (unsigned int)jarg6;
28023   {
28024     try {
28025       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28026     } catch (std::out_of_range& e) {
28027       {
28028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28029       };
28030     } catch (std::exception& e) {
28031       {
28032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28033       };
28034     } catch (...) {
28035       {
28036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28037       };
28038     }
28039   }
28040   jresult = (void *)result;
28041   return jresult;
28042 }
28043
28044
28045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28046   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28047
28048   arg1 = (Dali::WheelEvent *)jarg1;
28049   {
28050     try {
28051       delete arg1;
28052     } catch (std::out_of_range& e) {
28053       {
28054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28055       };
28056     } catch (std::exception& e) {
28057       {
28058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28059       };
28060     } catch (...) {
28061       {
28062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28063       };
28064     }
28065   }
28066 }
28067
28068
28069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28070   unsigned int jresult ;
28071   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28072   bool result;
28073
28074   arg1 = (Dali::WheelEvent *)jarg1;
28075   {
28076     try {
28077       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28078     } catch (std::out_of_range& e) {
28079       {
28080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28081       };
28082     } catch (std::exception& e) {
28083       {
28084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28085       };
28086     } catch (...) {
28087       {
28088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28089       };
28090     }
28091   }
28092   jresult = result;
28093   return jresult;
28094 }
28095
28096
28097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28098   unsigned int jresult ;
28099   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28100   bool result;
28101
28102   arg1 = (Dali::WheelEvent *)jarg1;
28103   {
28104     try {
28105       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28106     } catch (std::out_of_range& e) {
28107       {
28108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28109       };
28110     } catch (std::exception& e) {
28111       {
28112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28113       };
28114     } catch (...) {
28115       {
28116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28117       };
28118     }
28119   }
28120   jresult = result;
28121   return jresult;
28122 }
28123
28124
28125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28126   unsigned int jresult ;
28127   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28128   bool result;
28129
28130   arg1 = (Dali::WheelEvent *)jarg1;
28131   {
28132     try {
28133       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28134     } catch (std::out_of_range& e) {
28135       {
28136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28137       };
28138     } catch (std::exception& e) {
28139       {
28140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28141       };
28142     } catch (...) {
28143       {
28144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28145       };
28146     }
28147   }
28148   jresult = result;
28149   return jresult;
28150 }
28151
28152
28153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28154   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28155   Dali::WheelEvent::Type arg2 ;
28156
28157   arg1 = (Dali::WheelEvent *)jarg1;
28158   arg2 = (Dali::WheelEvent::Type)jarg2;
28159   if (arg1) (arg1)->type = arg2;
28160 }
28161
28162
28163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28164   int jresult ;
28165   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28166   Dali::WheelEvent::Type result;
28167
28168   arg1 = (Dali::WheelEvent *)jarg1;
28169   result = (Dali::WheelEvent::Type) ((arg1)->type);
28170   jresult = (int)result;
28171   return jresult;
28172 }
28173
28174
28175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28176   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28177   int arg2 ;
28178
28179   arg1 = (Dali::WheelEvent *)jarg1;
28180   arg2 = (int)jarg2;
28181   if (arg1) (arg1)->direction = arg2;
28182 }
28183
28184
28185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28186   int jresult ;
28187   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28188   int result;
28189
28190   arg1 = (Dali::WheelEvent *)jarg1;
28191   result = (int) ((arg1)->direction);
28192   jresult = result;
28193   return jresult;
28194 }
28195
28196
28197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28198   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28199   unsigned int arg2 ;
28200
28201   arg1 = (Dali::WheelEvent *)jarg1;
28202   arg2 = (unsigned int)jarg2;
28203   if (arg1) (arg1)->modifiers = arg2;
28204 }
28205
28206
28207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28208   unsigned int jresult ;
28209   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28210   unsigned int result;
28211
28212   arg1 = (Dali::WheelEvent *)jarg1;
28213   result = (unsigned int) ((arg1)->modifiers);
28214   jresult = result;
28215   return jresult;
28216 }
28217
28218
28219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28220   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28221   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28222
28223   arg1 = (Dali::WheelEvent *)jarg1;
28224   arg2 = (Dali::Vector2 *)jarg2;
28225   if (arg1) (arg1)->point = *arg2;
28226 }
28227
28228
28229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28230   void * jresult ;
28231   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28232   Dali::Vector2 *result = 0 ;
28233
28234   arg1 = (Dali::WheelEvent *)jarg1;
28235   result = (Dali::Vector2 *)& ((arg1)->point);
28236   jresult = (void *)result;
28237   return jresult;
28238 }
28239
28240
28241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28242   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28243   int arg2 ;
28244
28245   arg1 = (Dali::WheelEvent *)jarg1;
28246   arg2 = (int)jarg2;
28247   if (arg1) (arg1)->z = arg2;
28248 }
28249
28250
28251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28252   int jresult ;
28253   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28254   int result;
28255
28256   arg1 = (Dali::WheelEvent *)jarg1;
28257   result = (int) ((arg1)->z);
28258   jresult = result;
28259   return jresult;
28260 }
28261
28262
28263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28264   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28265   unsigned int arg2 ;
28266
28267   arg1 = (Dali::WheelEvent *)jarg1;
28268   arg2 = (unsigned int)jarg2;
28269   if (arg1) (arg1)->timeStamp = arg2;
28270 }
28271
28272
28273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28274   unsigned int jresult ;
28275   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28276   unsigned int result;
28277
28278   arg1 = (Dali::WheelEvent *)jarg1;
28279   result = (unsigned int) ((arg1)->timeStamp);
28280   jresult = result;
28281   return jresult;
28282 }
28283
28284
28285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28286   int jresult ;
28287   int result;
28288
28289   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28290   jresult = (int)result;
28291   return jresult;
28292 }
28293
28294
28295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28296   int jresult ;
28297   int result;
28298
28299   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28300   jresult = (int)result;
28301   return jresult;
28302 }
28303
28304
28305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28306   int jresult ;
28307   int result;
28308
28309   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28310   jresult = (int)result;
28311   return jresult;
28312 }
28313
28314
28315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28316   int jresult ;
28317   int result;
28318
28319   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28320   jresult = (int)result;
28321   return jresult;
28322 }
28323
28324
28325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28326   int jresult ;
28327   int result;
28328
28329   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28330   jresult = (int)result;
28331   return jresult;
28332 }
28333
28334
28335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28336   int jresult ;
28337   int result;
28338
28339   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28340   jresult = (int)result;
28341   return jresult;
28342 }
28343
28344
28345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28346   int jresult ;
28347   int result;
28348
28349   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28350   jresult = (int)result;
28351   return jresult;
28352 }
28353
28354
28355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28356   int jresult ;
28357   int result;
28358
28359   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28360   jresult = (int)result;
28361   return jresult;
28362 }
28363
28364
28365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28366   int jresult ;
28367   int result;
28368
28369   result = (int)Dali::Actor::Property::SIZE;
28370   jresult = (int)result;
28371   return jresult;
28372 }
28373
28374
28375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28376   int jresult ;
28377   int result;
28378
28379   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28380   jresult = (int)result;
28381   return jresult;
28382 }
28383
28384
28385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28386   int jresult ;
28387   int result;
28388
28389   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28390   jresult = (int)result;
28391   return jresult;
28392 }
28393
28394
28395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28396   int jresult ;
28397   int result;
28398
28399   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28400   jresult = (int)result;
28401   return jresult;
28402 }
28403
28404
28405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28406   int jresult ;
28407   int result;
28408
28409   result = (int)Dali::Actor::Property::POSITION;
28410   jresult = (int)result;
28411   return jresult;
28412 }
28413
28414
28415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28416   int jresult ;
28417   int result;
28418
28419   result = (int)Dali::Actor::Property::POSITION_X;
28420   jresult = (int)result;
28421   return jresult;
28422 }
28423
28424
28425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28426   int jresult ;
28427   int result;
28428
28429   result = (int)Dali::Actor::Property::POSITION_Y;
28430   jresult = (int)result;
28431   return jresult;
28432 }
28433
28434
28435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28436   int jresult ;
28437   int result;
28438
28439   result = (int)Dali::Actor::Property::POSITION_Z;
28440   jresult = (int)result;
28441   return jresult;
28442 }
28443
28444
28445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28446   int jresult ;
28447   int result;
28448
28449   result = (int)Dali::Actor::Property::WORLD_POSITION;
28450   jresult = (int)result;
28451   return jresult;
28452 }
28453
28454
28455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28456   int jresult ;
28457   int result;
28458
28459   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28460   jresult = (int)result;
28461   return jresult;
28462 }
28463
28464
28465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28466   int jresult ;
28467   int result;
28468
28469   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28470   jresult = (int)result;
28471   return jresult;
28472 }
28473
28474
28475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28476   int jresult ;
28477   int result;
28478
28479   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28480   jresult = (int)result;
28481   return jresult;
28482 }
28483
28484
28485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28486   int jresult ;
28487   int result;
28488
28489   result = (int)Dali::Actor::Property::ORIENTATION;
28490   jresult = (int)result;
28491   return jresult;
28492 }
28493
28494
28495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28496   int jresult ;
28497   int result;
28498
28499   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28500   jresult = (int)result;
28501   return jresult;
28502 }
28503
28504
28505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28506   int jresult ;
28507   int result;
28508
28509   result = (int)Dali::Actor::Property::SCALE;
28510   jresult = (int)result;
28511   return jresult;
28512 }
28513
28514
28515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28516   int jresult ;
28517   int result;
28518
28519   result = (int)Dali::Actor::Property::SCALE_X;
28520   jresult = (int)result;
28521   return jresult;
28522 }
28523
28524
28525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28526   int jresult ;
28527   int result;
28528
28529   result = (int)Dali::Actor::Property::SCALE_Y;
28530   jresult = (int)result;
28531   return jresult;
28532 }
28533
28534
28535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28536   int jresult ;
28537   int result;
28538
28539   result = (int)Dali::Actor::Property::SCALE_Z;
28540   jresult = (int)result;
28541   return jresult;
28542 }
28543
28544
28545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28546   int jresult ;
28547   int result;
28548
28549   result = (int)Dali::Actor::Property::WORLD_SCALE;
28550   jresult = (int)result;
28551   return jresult;
28552 }
28553
28554
28555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28556   int jresult ;
28557   int result;
28558
28559   result = (int)Dali::Actor::Property::VISIBLE;
28560   jresult = (int)result;
28561   return jresult;
28562 }
28563
28564
28565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28566   int jresult ;
28567   int result;
28568
28569   result = (int)Dali::Actor::Property::COLOR;
28570   jresult = (int)result;
28571   return jresult;
28572 }
28573
28574
28575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28576   int jresult ;
28577   int result;
28578
28579   result = (int)Dali::Actor::Property::COLOR_RED;
28580   jresult = (int)result;
28581   return jresult;
28582 }
28583
28584
28585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28586   int jresult ;
28587   int result;
28588
28589   result = (int)Dali::Actor::Property::COLOR_GREEN;
28590   jresult = (int)result;
28591   return jresult;
28592 }
28593
28594
28595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28596   int jresult ;
28597   int result;
28598
28599   result = (int)Dali::Actor::Property::COLOR_BLUE;
28600   jresult = (int)result;
28601   return jresult;
28602 }
28603
28604
28605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28606   int jresult ;
28607   int result;
28608
28609   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28610   jresult = (int)result;
28611   return jresult;
28612 }
28613
28614
28615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28616   int jresult ;
28617   int result;
28618
28619   result = (int)Dali::Actor::Property::WORLD_COLOR;
28620   jresult = (int)result;
28621   return jresult;
28622 }
28623
28624
28625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28626   int jresult ;
28627   int result;
28628
28629   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28630   jresult = (int)result;
28631   return jresult;
28632 }
28633
28634
28635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28636   int jresult ;
28637   int result;
28638
28639   result = (int)Dali::Actor::Property::NAME;
28640   jresult = (int)result;
28641   return jresult;
28642 }
28643
28644
28645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28646   int jresult ;
28647   int result;
28648
28649   result = (int)Dali::Actor::Property::SENSITIVE;
28650   jresult = (int)result;
28651   return jresult;
28652 }
28653
28654
28655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28656   int jresult ;
28657   int result;
28658
28659   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28660   jresult = (int)result;
28661   return jresult;
28662 }
28663
28664
28665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28666   int jresult ;
28667   int result;
28668
28669   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28670   jresult = (int)result;
28671   return jresult;
28672 }
28673
28674
28675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28676   int jresult ;
28677   int result;
28678
28679   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28680   jresult = (int)result;
28681   return jresult;
28682 }
28683
28684
28685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
28686   int jresult ;
28687   int result;
28688
28689   result = (int)Dali::Actor::Property::COLOR_MODE;
28690   jresult = (int)result;
28691   return jresult;
28692 }
28693
28694
28695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
28696   int jresult ;
28697   int result;
28698
28699   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28700   jresult = (int)result;
28701   return jresult;
28702 }
28703
28704
28705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
28706   int jresult ;
28707   int result;
28708
28709   result = (int)Dali::Actor::Property::DRAW_MODE;
28710   jresult = (int)result;
28711   return jresult;
28712 }
28713
28714
28715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
28716   int jresult ;
28717   int result;
28718
28719   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28720   jresult = (int)result;
28721   return jresult;
28722 }
28723
28724
28725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28726   int jresult ;
28727   int result;
28728
28729   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28730   jresult = (int)result;
28731   return jresult;
28732 }
28733
28734
28735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28736   int jresult ;
28737   int result;
28738
28739   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28740   jresult = (int)result;
28741   return jresult;
28742 }
28743
28744
28745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
28746   int jresult ;
28747   int result;
28748
28749   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28750   jresult = (int)result;
28751   return jresult;
28752 }
28753
28754
28755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
28756   int jresult ;
28757   int result;
28758
28759   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
28760   jresult = (int)result;
28761   return jresult;
28762 }
28763
28764
28765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
28766   int jresult ;
28767   int result;
28768
28769   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
28770   jresult = (int)result;
28771   return jresult;
28772 }
28773
28774
28775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
28776   int jresult ;
28777   int result;
28778
28779   result = (int)Dali::Actor::Property::PADDING;
28780   jresult = (int)result;
28781   return jresult;
28782 }
28783
28784
28785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
28786   int jresult ;
28787   int result;
28788
28789   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
28790   jresult = (int)result;
28791   return jresult;
28792 }
28793
28794
28795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
28796   int jresult ;
28797   int result;
28798
28799   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
28800   jresult = (int)result;
28801   return jresult;
28802 }
28803
28804
28805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
28806   int jresult ;
28807   int result;
28808
28809   result = (int)Dali::Actor::Property::INHERIT_POSITION;
28810   jresult = (int)result;
28811   return jresult;
28812 }
28813
28814
28815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
28816   int jresult ;
28817   int result;
28818
28819   result = (int)Dali::Actor::Property::CLIPPING_MODE;
28820   jresult = (int)result;
28821   return jresult;
28822 }
28823
28824
28825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
28826   void * jresult ;
28827   Dali::Actor::Property *result = 0 ;
28828
28829   {
28830     try {
28831       result = (Dali::Actor::Property *)new Dali::Actor::Property();
28832     } catch (std::out_of_range& e) {
28833       {
28834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28835       };
28836     } catch (std::exception& e) {
28837       {
28838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28839       };
28840     } catch (...) {
28841       {
28842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28843       };
28844     }
28845   }
28846   jresult = (void *)result;
28847   return jresult;
28848 }
28849
28850
28851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
28852   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
28853
28854   arg1 = (Dali::Actor::Property *)jarg1;
28855   {
28856     try {
28857       delete arg1;
28858     } catch (std::out_of_range& e) {
28859       {
28860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28861       };
28862     } catch (std::exception& e) {
28863       {
28864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28865       };
28866     } catch (...) {
28867       {
28868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28869       };
28870     }
28871   }
28872 }
28873
28874
28875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
28876   void * jresult ;
28877   Dali::Actor *result = 0 ;
28878
28879   {
28880     try {
28881       result = (Dali::Actor *)new Dali::Actor();
28882     } catch (std::out_of_range& e) {
28883       {
28884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28885       };
28886     } catch (std::exception& e) {
28887       {
28888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28889       };
28890     } catch (...) {
28891       {
28892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28893       };
28894     }
28895   }
28896   jresult = (void *)result;
28897   return jresult;
28898 }
28899
28900
28901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
28902   void * jresult ;
28903   Dali::Actor result;
28904
28905   {
28906     try {
28907       result = Dali::Actor::New();
28908     } catch (std::out_of_range& e) {
28909       {
28910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28911       };
28912     } catch (std::exception& e) {
28913       {
28914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28915       };
28916     } catch (...) {
28917       {
28918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28919       };
28920     }
28921   }
28922   jresult = new Dali::Actor((const Dali::Actor &)result);
28923   return jresult;
28924 }
28925
28926
28927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
28928   void * jresult ;
28929   Dali::BaseHandle arg1 ;
28930   Dali::BaseHandle *argp1 ;
28931   Dali::Actor result;
28932
28933   argp1 = (Dali::BaseHandle *)jarg1;
28934   if (!argp1) {
28935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28936     return 0;
28937   }
28938   arg1 = *argp1;
28939   {
28940     try {
28941       result = Dali::Actor::DownCast(arg1);
28942     } catch (std::out_of_range& e) {
28943       {
28944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28945       };
28946     } catch (std::exception& e) {
28947       {
28948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28949       };
28950     } catch (...) {
28951       {
28952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28953       };
28954     }
28955   }
28956   jresult = new Dali::Actor((const Dali::Actor &)result);
28957   return jresult;
28958 }
28959
28960
28961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
28962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28963
28964   arg1 = (Dali::Actor *)jarg1;
28965   {
28966     try {
28967       delete arg1;
28968     } catch (std::out_of_range& e) {
28969       {
28970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28971       };
28972     } catch (std::exception& e) {
28973       {
28974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28975       };
28976     } catch (...) {
28977       {
28978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28979       };
28980     }
28981   }
28982 }
28983
28984
28985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
28986   void * jresult ;
28987   Dali::Actor *arg1 = 0 ;
28988   Dali::Actor *result = 0 ;
28989
28990   arg1 = (Dali::Actor *)jarg1;
28991   if (!arg1) {
28992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
28993     return 0;
28994   }
28995   {
28996     try {
28997       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
28998     } catch (std::out_of_range& e) {
28999       {
29000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29001       };
29002     } catch (std::exception& e) {
29003       {
29004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29005       };
29006     } catch (...) {
29007       {
29008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29009       };
29010     }
29011   }
29012   jresult = (void *)result;
29013   return jresult;
29014 }
29015
29016
29017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29018   void * jresult ;
29019   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29020   Dali::Actor *arg2 = 0 ;
29021   Dali::Actor *result = 0 ;
29022
29023   arg1 = (Dali::Actor *)jarg1;
29024   arg2 = (Dali::Actor *)jarg2;
29025   if (!arg2) {
29026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29027     return 0;
29028   }
29029   {
29030     try {
29031       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29032     } catch (std::out_of_range& e) {
29033       {
29034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29035       };
29036     } catch (std::exception& e) {
29037       {
29038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29039       };
29040     } catch (...) {
29041       {
29042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29043       };
29044     }
29045   }
29046   jresult = (void *)result;
29047   return jresult;
29048 }
29049
29050
29051 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29052   char * jresult ;
29053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29054   std::string *result = 0 ;
29055
29056   arg1 = (Dali::Actor *)jarg1;
29057   {
29058     try {
29059       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29060     } catch (std::out_of_range& e) {
29061       {
29062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29063       };
29064     } catch (std::exception& e) {
29065       {
29066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29067       };
29068     } catch (...) {
29069       {
29070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29071       };
29072     }
29073   }
29074   jresult = SWIG_csharp_string_callback(result->c_str());
29075   return jresult;
29076 }
29077
29078
29079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29081   std::string *arg2 = 0 ;
29082
29083   arg1 = (Dali::Actor *)jarg1;
29084   if (!jarg2) {
29085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29086     return ;
29087   }
29088   std::string arg2_str(jarg2);
29089   arg2 = &arg2_str;
29090   {
29091     try {
29092       (arg1)->SetName((std::string const &)*arg2);
29093     } catch (std::out_of_range& e) {
29094       {
29095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29096       };
29097     } catch (std::exception& e) {
29098       {
29099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29100       };
29101     } catch (...) {
29102       {
29103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29104       };
29105     }
29106   }
29107
29108   //argout typemap for const std::string&
29109
29110 }
29111
29112
29113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29114   unsigned int jresult ;
29115   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29116   unsigned int result;
29117
29118   arg1 = (Dali::Actor *)jarg1;
29119   {
29120     try {
29121       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29122     } catch (std::out_of_range& e) {
29123       {
29124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29125       };
29126     } catch (std::exception& e) {
29127       {
29128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29129       };
29130     } catch (...) {
29131       {
29132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29133       };
29134     }
29135   }
29136   jresult = result;
29137   return jresult;
29138 }
29139
29140
29141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29142   unsigned int jresult ;
29143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29144   bool result;
29145
29146   arg1 = (Dali::Actor *)jarg1;
29147   {
29148     try {
29149       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29150     } catch (std::out_of_range& e) {
29151       {
29152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29153       };
29154     } catch (std::exception& e) {
29155       {
29156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29157       };
29158     } catch (...) {
29159       {
29160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29161       };
29162     }
29163   }
29164   jresult = result;
29165   return jresult;
29166 }
29167
29168
29169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29170   unsigned int jresult ;
29171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29172   bool result;
29173
29174   arg1 = (Dali::Actor *)jarg1;
29175   {
29176     try {
29177       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29178     } catch (std::out_of_range& e) {
29179       {
29180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29181       };
29182     } catch (std::exception& e) {
29183       {
29184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29185       };
29186     } catch (...) {
29187       {
29188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29189       };
29190     }
29191   }
29192   jresult = result;
29193   return jresult;
29194 }
29195
29196
29197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29198   unsigned int jresult ;
29199   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29200   bool result;
29201
29202   arg1 = (Dali::Actor *)jarg1;
29203   {
29204     try {
29205       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29206     } catch (std::out_of_range& e) {
29207       {
29208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29209       };
29210     } catch (std::exception& e) {
29211       {
29212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29213       };
29214     } catch (...) {
29215       {
29216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29217       };
29218     }
29219   }
29220   jresult = result;
29221   return jresult;
29222 }
29223
29224
29225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29226   void * jresult ;
29227   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29228   Dali::Layer result;
29229
29230   arg1 = (Dali::Actor *)jarg1;
29231   {
29232     try {
29233       result = (arg1)->GetLayer();
29234     } catch (std::out_of_range& e) {
29235       {
29236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29237       };
29238     } catch (std::exception& e) {
29239       {
29240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29241       };
29242     } catch (...) {
29243       {
29244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29245       };
29246     }
29247   }
29248   jresult = new Dali::Layer((const Dali::Layer &)result);
29249   return jresult;
29250 }
29251
29252
29253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29255   Dali::Actor arg2 ;
29256   Dali::Actor *argp2 ;
29257
29258   arg1 = (Dali::Actor *)jarg1;
29259   argp2 = (Dali::Actor *)jarg2;
29260   if (!argp2) {
29261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29262     return ;
29263   }
29264   arg2 = *argp2;
29265   {
29266     try {
29267       (arg1)->Add(arg2);
29268     } catch (std::out_of_range& e) {
29269       {
29270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29271       };
29272     } catch (std::exception& e) {
29273       {
29274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29275       };
29276     } catch (...) {
29277       {
29278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29279       };
29280     }
29281   }
29282 }
29283
29284
29285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29287   Dali::Actor arg2 ;
29288   Dali::Actor *argp2 ;
29289
29290   arg1 = (Dali::Actor *)jarg1;
29291   argp2 = (Dali::Actor *)jarg2;
29292   if (!argp2) {
29293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29294     return ;
29295   }
29296   arg2 = *argp2;
29297   {
29298     try {
29299       (arg1)->Remove(arg2);
29300     } catch (std::out_of_range& e) {
29301       {
29302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29303       };
29304     } catch (std::exception& e) {
29305       {
29306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29307       };
29308     } catch (...) {
29309       {
29310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29311       };
29312     }
29313   }
29314 }
29315
29316
29317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29318   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29319
29320   arg1 = (Dali::Actor *)jarg1;
29321   {
29322     try {
29323       (arg1)->Unparent();
29324     } catch (std::out_of_range& e) {
29325       {
29326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29327       };
29328     } catch (std::exception& e) {
29329       {
29330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29331       };
29332     } catch (...) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29335       };
29336     }
29337   }
29338 }
29339
29340
29341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29342   unsigned int jresult ;
29343   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29344   unsigned int result;
29345
29346   arg1 = (Dali::Actor *)jarg1;
29347   {
29348     try {
29349       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29350     } catch (std::out_of_range& e) {
29351       {
29352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29353       };
29354     } catch (std::exception& e) {
29355       {
29356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29357       };
29358     } catch (...) {
29359       {
29360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29361       };
29362     }
29363   }
29364   jresult = result;
29365   return jresult;
29366 }
29367
29368
29369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29370   void * jresult ;
29371   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29372   unsigned int arg2 ;
29373   Dali::Actor result;
29374
29375   arg1 = (Dali::Actor *)jarg1;
29376   arg2 = (unsigned int)jarg2;
29377   {
29378     try {
29379       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29380     } catch (std::out_of_range& e) {
29381       {
29382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29383       };
29384     } catch (std::exception& e) {
29385       {
29386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29387       };
29388     } catch (...) {
29389       {
29390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29391       };
29392     }
29393   }
29394   jresult = new Dali::Actor((const Dali::Actor &)result);
29395   return jresult;
29396 }
29397
29398
29399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29400   void * jresult ;
29401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29402   std::string *arg2 = 0 ;
29403   Dali::Actor result;
29404
29405   arg1 = (Dali::Actor *)jarg1;
29406   if (!jarg2) {
29407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29408     return 0;
29409   }
29410   std::string arg2_str(jarg2);
29411   arg2 = &arg2_str;
29412   {
29413     try {
29414       result = (arg1)->FindChildByName((std::string const &)*arg2);
29415     } catch (std::out_of_range& e) {
29416       {
29417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29418       };
29419     } catch (std::exception& e) {
29420       {
29421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29422       };
29423     } catch (...) {
29424       {
29425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29426       };
29427     }
29428   }
29429   jresult = new Dali::Actor((const Dali::Actor &)result);
29430
29431   //argout typemap for const std::string&
29432
29433   return jresult;
29434 }
29435
29436
29437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29438   void * jresult ;
29439   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29440   unsigned int arg2 ;
29441   Dali::Actor result;
29442
29443   arg1 = (Dali::Actor *)jarg1;
29444   arg2 = (unsigned int)jarg2;
29445   {
29446     try {
29447       result = (arg1)->FindChildById(arg2);
29448     } catch (std::out_of_range& e) {
29449       {
29450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29451       };
29452     } catch (std::exception& e) {
29453       {
29454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29455       };
29456     } catch (...) {
29457       {
29458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29459       };
29460     }
29461   }
29462   jresult = new Dali::Actor((const Dali::Actor &)result);
29463   return jresult;
29464 }
29465
29466
29467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29468   void * jresult ;
29469   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29470   Dali::Actor result;
29471
29472   arg1 = (Dali::Actor *)jarg1;
29473   {
29474     try {
29475       result = ((Dali::Actor const *)arg1)->GetParent();
29476     } catch (std::out_of_range& e) {
29477       {
29478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29479       };
29480     } catch (std::exception& e) {
29481       {
29482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29483       };
29484     } catch (...) {
29485       {
29486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29487       };
29488     }
29489   }
29490   jresult = new Dali::Actor((const Dali::Actor &)result);
29491   return jresult;
29492 }
29493
29494
29495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29497   Dali::Vector3 *arg2 = 0 ;
29498
29499   arg1 = (Dali::Actor *)jarg1;
29500   arg2 = (Dali::Vector3 *)jarg2;
29501   if (!arg2) {
29502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29503     return ;
29504   }
29505   {
29506     try {
29507       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29508     } catch (std::out_of_range& e) {
29509       {
29510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29511       };
29512     } catch (std::exception& e) {
29513       {
29514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29515       };
29516     } catch (...) {
29517       {
29518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29519       };
29520     }
29521   }
29522 }
29523
29524
29525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29526   void * jresult ;
29527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29528   Dali::Vector3 result;
29529
29530   arg1 = (Dali::Actor *)jarg1;
29531   {
29532     try {
29533       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29534     } catch (std::out_of_range& e) {
29535       {
29536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29537       };
29538     } catch (std::exception& e) {
29539       {
29540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29541       };
29542     } catch (...) {
29543       {
29544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29545       };
29546     }
29547   }
29548   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29549   return jresult;
29550 }
29551
29552
29553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29555   Dali::Vector3 *arg2 = 0 ;
29556
29557   arg1 = (Dali::Actor *)jarg1;
29558   arg2 = (Dali::Vector3 *)jarg2;
29559   if (!arg2) {
29560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29561     return ;
29562   }
29563   {
29564     try {
29565       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29566     } catch (std::out_of_range& e) {
29567       {
29568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29569       };
29570     } catch (std::exception& e) {
29571       {
29572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29573       };
29574     } catch (...) {
29575       {
29576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29577       };
29578     }
29579   }
29580 }
29581
29582
29583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29584   void * jresult ;
29585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29586   Dali::Vector3 result;
29587
29588   arg1 = (Dali::Actor *)jarg1;
29589   {
29590     try {
29591       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29592     } catch (std::out_of_range& e) {
29593       {
29594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29595       };
29596     } catch (std::exception& e) {
29597       {
29598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29599       };
29600     } catch (...) {
29601       {
29602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29603       };
29604     }
29605   }
29606   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29607   return jresult;
29608 }
29609
29610
29611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29612   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29613   float arg2 ;
29614   float arg3 ;
29615
29616   arg1 = (Dali::Actor *)jarg1;
29617   arg2 = (float)jarg2;
29618   arg3 = (float)jarg3;
29619   {
29620     try {
29621       (arg1)->SetSize(arg2,arg3);
29622     } catch (std::out_of_range& e) {
29623       {
29624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29625       };
29626     } catch (std::exception& e) {
29627       {
29628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29629       };
29630     } catch (...) {
29631       {
29632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29633       };
29634     }
29635   }
29636 }
29637
29638
29639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29640   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29641   float arg2 ;
29642   float arg3 ;
29643   float arg4 ;
29644
29645   arg1 = (Dali::Actor *)jarg1;
29646   arg2 = (float)jarg2;
29647   arg3 = (float)jarg3;
29648   arg4 = (float)jarg4;
29649   {
29650     try {
29651       (arg1)->SetSize(arg2,arg3,arg4);
29652     } catch (std::out_of_range& e) {
29653       {
29654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29655       };
29656     } catch (std::exception& e) {
29657       {
29658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29659       };
29660     } catch (...) {
29661       {
29662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29663       };
29664     }
29665   }
29666 }
29667
29668
29669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29671   Dali::Vector2 *arg2 = 0 ;
29672
29673   arg1 = (Dali::Actor *)jarg1;
29674   arg2 = (Dali::Vector2 *)jarg2;
29675   if (!arg2) {
29676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29677     return ;
29678   }
29679   {
29680     try {
29681       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29682     } catch (std::out_of_range& e) {
29683       {
29684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29685       };
29686     } catch (std::exception& e) {
29687       {
29688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29689       };
29690     } catch (...) {
29691       {
29692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29693       };
29694     }
29695   }
29696 }
29697
29698
29699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29700   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29701   Dali::Vector3 *arg2 = 0 ;
29702
29703   arg1 = (Dali::Actor *)jarg1;
29704   arg2 = (Dali::Vector3 *)jarg2;
29705   if (!arg2) {
29706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29707     return ;
29708   }
29709   {
29710     try {
29711       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29712     } catch (std::out_of_range& e) {
29713       {
29714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29715       };
29716     } catch (std::exception& e) {
29717       {
29718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29719       };
29720     } catch (...) {
29721       {
29722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29723       };
29724     }
29725   }
29726 }
29727
29728
29729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
29730   void * jresult ;
29731   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29732   Dali::Vector3 result;
29733
29734   arg1 = (Dali::Actor *)jarg1;
29735   {
29736     try {
29737       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29738     } catch (std::out_of_range& e) {
29739       {
29740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29741       };
29742     } catch (std::exception& e) {
29743       {
29744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29745       };
29746     } catch (...) {
29747       {
29748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29749       };
29750     }
29751   }
29752   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29753   return jresult;
29754 }
29755
29756
29757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
29758   void * jresult ;
29759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29760   Dali::Vector3 result;
29761
29762   arg1 = (Dali::Actor *)jarg1;
29763   {
29764     try {
29765       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
29766     } catch (std::out_of_range& e) {
29767       {
29768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29769       };
29770     } catch (std::exception& e) {
29771       {
29772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29773       };
29774     } catch (...) {
29775       {
29776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29777       };
29778     }
29779   }
29780   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29781   return jresult;
29782 }
29783
29784
29785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
29786   void * jresult ;
29787   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29788   Dali::Vector3 result;
29789
29790   arg1 = (Dali::Actor *)jarg1;
29791   {
29792     try {
29793       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
29794     } catch (std::out_of_range& e) {
29795       {
29796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29797       };
29798     } catch (std::exception& e) {
29799       {
29800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29801       };
29802     } catch (...) {
29803       {
29804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29805       };
29806     }
29807   }
29808   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29809   return jresult;
29810 }
29811
29812
29813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29815   float arg2 ;
29816   float arg3 ;
29817
29818   arg1 = (Dali::Actor *)jarg1;
29819   arg2 = (float)jarg2;
29820   arg3 = (float)jarg3;
29821   {
29822     try {
29823       (arg1)->SetPosition(arg2,arg3);
29824     } catch (std::out_of_range& e) {
29825       {
29826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29827       };
29828     } catch (std::exception& e) {
29829       {
29830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29831       };
29832     } catch (...) {
29833       {
29834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29835       };
29836     }
29837   }
29838 }
29839
29840
29841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29842   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29843   float arg2 ;
29844   float arg3 ;
29845   float arg4 ;
29846
29847   arg1 = (Dali::Actor *)jarg1;
29848   arg2 = (float)jarg2;
29849   arg3 = (float)jarg3;
29850   arg4 = (float)jarg4;
29851   {
29852     try {
29853       (arg1)->SetPosition(arg2,arg3,arg4);
29854     } catch (std::out_of_range& e) {
29855       {
29856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29857       };
29858     } catch (std::exception& e) {
29859       {
29860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29861       };
29862     } catch (...) {
29863       {
29864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29865       };
29866     }
29867   }
29868 }
29869
29870
29871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
29872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29873   Dali::Vector3 *arg2 = 0 ;
29874
29875   arg1 = (Dali::Actor *)jarg1;
29876   arg2 = (Dali::Vector3 *)jarg2;
29877   if (!arg2) {
29878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29879     return ;
29880   }
29881   {
29882     try {
29883       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
29884     } catch (std::out_of_range& e) {
29885       {
29886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29887       };
29888     } catch (std::exception& e) {
29889       {
29890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29891       };
29892     } catch (...) {
29893       {
29894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29895       };
29896     }
29897   }
29898 }
29899
29900
29901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
29902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29903   float arg2 ;
29904
29905   arg1 = (Dali::Actor *)jarg1;
29906   arg2 = (float)jarg2;
29907   {
29908     try {
29909       (arg1)->SetX(arg2);
29910     } catch (std::out_of_range& e) {
29911       {
29912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29913       };
29914     } catch (std::exception& e) {
29915       {
29916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29917       };
29918     } catch (...) {
29919       {
29920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29921       };
29922     }
29923   }
29924 }
29925
29926
29927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
29928   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29929   float arg2 ;
29930
29931   arg1 = (Dali::Actor *)jarg1;
29932   arg2 = (float)jarg2;
29933   {
29934     try {
29935       (arg1)->SetY(arg2);
29936     } catch (std::out_of_range& e) {
29937       {
29938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29939       };
29940     } catch (std::exception& e) {
29941       {
29942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29943       };
29944     } catch (...) {
29945       {
29946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29947       };
29948     }
29949   }
29950 }
29951
29952
29953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
29954   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29955   float arg2 ;
29956
29957   arg1 = (Dali::Actor *)jarg1;
29958   arg2 = (float)jarg2;
29959   {
29960     try {
29961       (arg1)->SetZ(arg2);
29962     } catch (std::out_of_range& e) {
29963       {
29964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29965       };
29966     } catch (std::exception& e) {
29967       {
29968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29969       };
29970     } catch (...) {
29971       {
29972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29973       };
29974     }
29975   }
29976 }
29977
29978
29979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
29980   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29981   Dali::Vector3 *arg2 = 0 ;
29982
29983   arg1 = (Dali::Actor *)jarg1;
29984   arg2 = (Dali::Vector3 *)jarg2;
29985   if (!arg2) {
29986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29987     return ;
29988   }
29989   {
29990     try {
29991       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
29992     } catch (std::out_of_range& e) {
29993       {
29994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29995       };
29996     } catch (std::exception& e) {
29997       {
29998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29999       };
30000     } catch (...) {
30001       {
30002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30003       };
30004     }
30005   }
30006 }
30007
30008
30009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30010   void * jresult ;
30011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30012   Dali::Vector3 result;
30013
30014   arg1 = (Dali::Actor *)jarg1;
30015   {
30016     try {
30017       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30018     } catch (std::out_of_range& e) {
30019       {
30020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30021       };
30022     } catch (std::exception& e) {
30023       {
30024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30025       };
30026     } catch (...) {
30027       {
30028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30029       };
30030     }
30031   }
30032   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30033   return jresult;
30034 }
30035
30036
30037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30038   void * jresult ;
30039   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30040   Dali::Vector3 result;
30041
30042   arg1 = (Dali::Actor *)jarg1;
30043   {
30044     try {
30045       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30046     } catch (std::out_of_range& e) {
30047       {
30048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30049       };
30050     } catch (std::exception& e) {
30051       {
30052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30053       };
30054     } catch (...) {
30055       {
30056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30057       };
30058     }
30059   }
30060   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30061   return jresult;
30062 }
30063
30064
30065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30067   bool arg2 ;
30068
30069   arg1 = (Dali::Actor *)jarg1;
30070   arg2 = jarg2 ? true : false;
30071   {
30072     try {
30073       (arg1)->SetInheritPosition(arg2);
30074     } catch (std::out_of_range& e) {
30075       {
30076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30077       };
30078     } catch (std::exception& e) {
30079       {
30080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30081       };
30082     } catch (...) {
30083       {
30084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30085       };
30086     }
30087   }
30088 }
30089
30090
30091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30092   int jresult ;
30093   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30094   Dali::PositionInheritanceMode result;
30095
30096   arg1 = (Dali::Actor *)jarg1;
30097   {
30098     try {
30099       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30100     } catch (std::out_of_range& e) {
30101       {
30102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30103       };
30104     } catch (std::exception& e) {
30105       {
30106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30107       };
30108     } catch (...) {
30109       {
30110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30111       };
30112     }
30113   }
30114   jresult = (int)result;
30115   return jresult;
30116 }
30117
30118
30119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30120   unsigned int jresult ;
30121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30122   bool result;
30123
30124   arg1 = (Dali::Actor *)jarg1;
30125   {
30126     try {
30127       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30128     } catch (std::out_of_range& e) {
30129       {
30130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30131       };
30132     } catch (std::exception& e) {
30133       {
30134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30135       };
30136     } catch (...) {
30137       {
30138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30139       };
30140     }
30141   }
30142   jresult = result;
30143   return jresult;
30144 }
30145
30146
30147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30148   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30149   Dali::Degree *arg2 = 0 ;
30150   Dali::Vector3 *arg3 = 0 ;
30151
30152   arg1 = (Dali::Actor *)jarg1;
30153   arg2 = (Dali::Degree *)jarg2;
30154   if (!arg2) {
30155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30156     return ;
30157   }
30158   arg3 = (Dali::Vector3 *)jarg3;
30159   if (!arg3) {
30160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30161     return ;
30162   }
30163   {
30164     try {
30165       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30166     } catch (std::out_of_range& e) {
30167       {
30168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30169       };
30170     } catch (std::exception& e) {
30171       {
30172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30173       };
30174     } catch (...) {
30175       {
30176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30177       };
30178     }
30179   }
30180 }
30181
30182
30183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30184   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30185   Dali::Radian *arg2 = 0 ;
30186   Dali::Vector3 *arg3 = 0 ;
30187
30188   arg1 = (Dali::Actor *)jarg1;
30189   arg2 = (Dali::Radian *)jarg2;
30190   if (!arg2) {
30191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30192     return ;
30193   }
30194   arg3 = (Dali::Vector3 *)jarg3;
30195   if (!arg3) {
30196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30197     return ;
30198   }
30199   {
30200     try {
30201       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30202     } catch (std::out_of_range& e) {
30203       {
30204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30205       };
30206     } catch (std::exception& e) {
30207       {
30208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30209       };
30210     } catch (...) {
30211       {
30212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30213       };
30214     }
30215   }
30216 }
30217
30218
30219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30220   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30221   Dali::Quaternion *arg2 = 0 ;
30222
30223   arg1 = (Dali::Actor *)jarg1;
30224   arg2 = (Dali::Quaternion *)jarg2;
30225   if (!arg2) {
30226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30227     return ;
30228   }
30229   {
30230     try {
30231       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30232     } catch (std::out_of_range& e) {
30233       {
30234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30235       };
30236     } catch (std::exception& e) {
30237       {
30238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30239       };
30240     } catch (...) {
30241       {
30242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30243       };
30244     }
30245   }
30246 }
30247
30248
30249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30251   Dali::Degree *arg2 = 0 ;
30252   Dali::Vector3 *arg3 = 0 ;
30253
30254   arg1 = (Dali::Actor *)jarg1;
30255   arg2 = (Dali::Degree *)jarg2;
30256   if (!arg2) {
30257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30258     return ;
30259   }
30260   arg3 = (Dali::Vector3 *)jarg3;
30261   if (!arg3) {
30262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30263     return ;
30264   }
30265   {
30266     try {
30267       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30268     } catch (std::out_of_range& e) {
30269       {
30270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30271       };
30272     } catch (std::exception& e) {
30273       {
30274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30275       };
30276     } catch (...) {
30277       {
30278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30279       };
30280     }
30281   }
30282 }
30283
30284
30285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30287   Dali::Radian *arg2 = 0 ;
30288   Dali::Vector3 *arg3 = 0 ;
30289
30290   arg1 = (Dali::Actor *)jarg1;
30291   arg2 = (Dali::Radian *)jarg2;
30292   if (!arg2) {
30293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30294     return ;
30295   }
30296   arg3 = (Dali::Vector3 *)jarg3;
30297   if (!arg3) {
30298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30299     return ;
30300   }
30301   {
30302     try {
30303       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30304     } catch (std::out_of_range& e) {
30305       {
30306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30307       };
30308     } catch (std::exception& e) {
30309       {
30310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30311       };
30312     } catch (...) {
30313       {
30314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30315       };
30316     }
30317   }
30318 }
30319
30320
30321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30323   Dali::Quaternion *arg2 = 0 ;
30324
30325   arg1 = (Dali::Actor *)jarg1;
30326   arg2 = (Dali::Quaternion *)jarg2;
30327   if (!arg2) {
30328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30329     return ;
30330   }
30331   {
30332     try {
30333       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30334     } catch (std::out_of_range& e) {
30335       {
30336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30337       };
30338     } catch (std::exception& e) {
30339       {
30340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30341       };
30342     } catch (...) {
30343       {
30344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30345       };
30346     }
30347   }
30348 }
30349
30350
30351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30352   void * jresult ;
30353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30354   Dali::Quaternion result;
30355
30356   arg1 = (Dali::Actor *)jarg1;
30357   {
30358     try {
30359       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30360     } catch (std::out_of_range& e) {
30361       {
30362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30363       };
30364     } catch (std::exception& e) {
30365       {
30366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30367       };
30368     } catch (...) {
30369       {
30370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30371       };
30372     }
30373   }
30374   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30375   return jresult;
30376 }
30377
30378
30379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30381   bool arg2 ;
30382
30383   arg1 = (Dali::Actor *)jarg1;
30384   arg2 = jarg2 ? true : false;
30385   {
30386     try {
30387       (arg1)->SetInheritOrientation(arg2);
30388     } catch (std::out_of_range& e) {
30389       {
30390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30391       };
30392     } catch (std::exception& e) {
30393       {
30394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30395       };
30396     } catch (...) {
30397       {
30398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30399       };
30400     }
30401   }
30402 }
30403
30404
30405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30406   unsigned int jresult ;
30407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30408   bool result;
30409
30410   arg1 = (Dali::Actor *)jarg1;
30411   {
30412     try {
30413       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30414     } catch (std::out_of_range& e) {
30415       {
30416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30417       };
30418     } catch (std::exception& e) {
30419       {
30420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30421       };
30422     } catch (...) {
30423       {
30424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30425       };
30426     }
30427   }
30428   jresult = result;
30429   return jresult;
30430 }
30431
30432
30433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30434   void * jresult ;
30435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30436   Dali::Quaternion result;
30437
30438   arg1 = (Dali::Actor *)jarg1;
30439   {
30440     try {
30441       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30442     } catch (std::out_of_range& e) {
30443       {
30444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30445       };
30446     } catch (std::exception& e) {
30447       {
30448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30449       };
30450     } catch (...) {
30451       {
30452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30453       };
30454     }
30455   }
30456   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30457   return jresult;
30458 }
30459
30460
30461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30463   float arg2 ;
30464
30465   arg1 = (Dali::Actor *)jarg1;
30466   arg2 = (float)jarg2;
30467   {
30468     try {
30469       (arg1)->SetScale(arg2);
30470     } catch (std::out_of_range& e) {
30471       {
30472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30473       };
30474     } catch (std::exception& e) {
30475       {
30476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30477       };
30478     } catch (...) {
30479       {
30480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30481       };
30482     }
30483   }
30484 }
30485
30486
30487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30489   float arg2 ;
30490   float arg3 ;
30491   float arg4 ;
30492
30493   arg1 = (Dali::Actor *)jarg1;
30494   arg2 = (float)jarg2;
30495   arg3 = (float)jarg3;
30496   arg4 = (float)jarg4;
30497   {
30498     try {
30499       (arg1)->SetScale(arg2,arg3,arg4);
30500     } catch (std::out_of_range& e) {
30501       {
30502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30503       };
30504     } catch (std::exception& e) {
30505       {
30506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30507       };
30508     } catch (...) {
30509       {
30510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30511       };
30512     }
30513   }
30514 }
30515
30516
30517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30518   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30519   Dali::Vector3 *arg2 = 0 ;
30520
30521   arg1 = (Dali::Actor *)jarg1;
30522   arg2 = (Dali::Vector3 *)jarg2;
30523   if (!arg2) {
30524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30525     return ;
30526   }
30527   {
30528     try {
30529       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30530     } catch (std::out_of_range& e) {
30531       {
30532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30533       };
30534     } catch (std::exception& e) {
30535       {
30536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30537       };
30538     } catch (...) {
30539       {
30540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30541       };
30542     }
30543   }
30544 }
30545
30546
30547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30548   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30549   Dali::Vector3 *arg2 = 0 ;
30550
30551   arg1 = (Dali::Actor *)jarg1;
30552   arg2 = (Dali::Vector3 *)jarg2;
30553   if (!arg2) {
30554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30555     return ;
30556   }
30557   {
30558     try {
30559       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30560     } catch (std::out_of_range& e) {
30561       {
30562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30563       };
30564     } catch (std::exception& e) {
30565       {
30566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30567       };
30568     } catch (...) {
30569       {
30570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30571       };
30572     }
30573   }
30574 }
30575
30576
30577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30578   void * jresult ;
30579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30580   Dali::Vector3 result;
30581
30582   arg1 = (Dali::Actor *)jarg1;
30583   {
30584     try {
30585       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30586     } catch (std::out_of_range& e) {
30587       {
30588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30589       };
30590     } catch (std::exception& e) {
30591       {
30592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30593       };
30594     } catch (...) {
30595       {
30596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30597       };
30598     }
30599   }
30600   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30601   return jresult;
30602 }
30603
30604
30605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30606   void * jresult ;
30607   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30608   Dali::Vector3 result;
30609
30610   arg1 = (Dali::Actor *)jarg1;
30611   {
30612     try {
30613       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30614     } catch (std::out_of_range& e) {
30615       {
30616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30617       };
30618     } catch (std::exception& e) {
30619       {
30620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30621       };
30622     } catch (...) {
30623       {
30624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30625       };
30626     }
30627   }
30628   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30629   return jresult;
30630 }
30631
30632
30633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30635   bool arg2 ;
30636
30637   arg1 = (Dali::Actor *)jarg1;
30638   arg2 = jarg2 ? true : false;
30639   {
30640     try {
30641       (arg1)->SetInheritScale(arg2);
30642     } catch (std::out_of_range& e) {
30643       {
30644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30645       };
30646     } catch (std::exception& e) {
30647       {
30648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30649       };
30650     } catch (...) {
30651       {
30652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30653       };
30654     }
30655   }
30656 }
30657
30658
30659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30660   unsigned int jresult ;
30661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30662   bool result;
30663
30664   arg1 = (Dali::Actor *)jarg1;
30665   {
30666     try {
30667       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30668     } catch (std::out_of_range& e) {
30669       {
30670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30671       };
30672     } catch (std::exception& e) {
30673       {
30674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30675       };
30676     } catch (...) {
30677       {
30678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30679       };
30680     }
30681   }
30682   jresult = result;
30683   return jresult;
30684 }
30685
30686
30687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
30688   void * jresult ;
30689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30690   Dali::Matrix result;
30691
30692   arg1 = (Dali::Actor *)jarg1;
30693   {
30694     try {
30695       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30696     } catch (std::out_of_range& e) {
30697       {
30698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30699       };
30700     } catch (std::exception& e) {
30701       {
30702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30703       };
30704     } catch (...) {
30705       {
30706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30707       };
30708     }
30709   }
30710   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30711   return jresult;
30712 }
30713
30714
30715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30716   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30717   bool arg2 ;
30718
30719   arg1 = (Dali::Actor *)jarg1;
30720   arg2 = jarg2 ? true : false;
30721   {
30722     try {
30723       (arg1)->SetVisible(arg2);
30724     } catch (std::out_of_range& e) {
30725       {
30726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30727       };
30728     } catch (std::exception& e) {
30729       {
30730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30731       };
30732     } catch (...) {
30733       {
30734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30735       };
30736     }
30737   }
30738 }
30739
30740
30741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
30742   unsigned int jresult ;
30743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30744   bool result;
30745
30746   arg1 = (Dali::Actor *)jarg1;
30747   {
30748     try {
30749       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30750     } catch (std::out_of_range& e) {
30751       {
30752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30753       };
30754     } catch (std::exception& e) {
30755       {
30756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30757       };
30758     } catch (...) {
30759       {
30760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30761       };
30762     }
30763   }
30764   jresult = result;
30765   return jresult;
30766 }
30767
30768
30769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
30770   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30771   float arg2 ;
30772
30773   arg1 = (Dali::Actor *)jarg1;
30774   arg2 = (float)jarg2;
30775   {
30776     try {
30777       (arg1)->SetOpacity(arg2);
30778     } catch (std::out_of_range& e) {
30779       {
30780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30781       };
30782     } catch (std::exception& e) {
30783       {
30784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30785       };
30786     } catch (...) {
30787       {
30788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30789       };
30790     }
30791   }
30792 }
30793
30794
30795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
30796   float jresult ;
30797   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30798   float result;
30799
30800   arg1 = (Dali::Actor *)jarg1;
30801   {
30802     try {
30803       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
30804     } catch (std::out_of_range& e) {
30805       {
30806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30807       };
30808     } catch (std::exception& e) {
30809       {
30810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30811       };
30812     } catch (...) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30815       };
30816     }
30817   }
30818   jresult = result;
30819   return jresult;
30820 }
30821
30822
30823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
30824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30825   Dali::Vector4 *arg2 = 0 ;
30826
30827   arg1 = (Dali::Actor *)jarg1;
30828   arg2 = (Dali::Vector4 *)jarg2;
30829   if (!arg2) {
30830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
30831     return ;
30832   }
30833   {
30834     try {
30835       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
30836     } catch (std::out_of_range& e) {
30837       {
30838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30839       };
30840     } catch (std::exception& e) {
30841       {
30842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30843       };
30844     } catch (...) {
30845       {
30846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30847       };
30848     }
30849   }
30850 }
30851
30852
30853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
30854   void * jresult ;
30855   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30856   Dali::Vector4 result;
30857
30858   arg1 = (Dali::Actor *)jarg1;
30859   {
30860     try {
30861       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
30862     } catch (std::out_of_range& e) {
30863       {
30864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30865       };
30866     } catch (std::exception& e) {
30867       {
30868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30869       };
30870     } catch (...) {
30871       {
30872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30873       };
30874     }
30875   }
30876   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30877   return jresult;
30878 }
30879
30880
30881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
30882   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30883   Dali::ColorMode arg2 ;
30884
30885   arg1 = (Dali::Actor *)jarg1;
30886   arg2 = (Dali::ColorMode)jarg2;
30887   {
30888     try {
30889       (arg1)->SetColorMode(arg2);
30890     } catch (std::out_of_range& e) {
30891       {
30892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30893       };
30894     } catch (std::exception& e) {
30895       {
30896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30897       };
30898     } catch (...) {
30899       {
30900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30901       };
30902     }
30903   }
30904 }
30905
30906
30907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
30908   int jresult ;
30909   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30910   Dali::ColorMode result;
30911
30912   arg1 = (Dali::Actor *)jarg1;
30913   {
30914     try {
30915       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
30916     } catch (std::out_of_range& e) {
30917       {
30918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30919       };
30920     } catch (std::exception& e) {
30921       {
30922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30923       };
30924     } catch (...) {
30925       {
30926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30927       };
30928     }
30929   }
30930   jresult = (int)result;
30931   return jresult;
30932 }
30933
30934
30935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
30936   void * jresult ;
30937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30938   Dali::Vector4 result;
30939
30940   arg1 = (Dali::Actor *)jarg1;
30941   {
30942     try {
30943       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
30944     } catch (std::out_of_range& e) {
30945       {
30946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30947       };
30948     } catch (std::exception& e) {
30949       {
30950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30951       };
30952     } catch (...) {
30953       {
30954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30955       };
30956     }
30957   }
30958   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30959   return jresult;
30960 }
30961
30962
30963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
30964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30965   Dali::DrawMode::Type arg2 ;
30966
30967   arg1 = (Dali::Actor *)jarg1;
30968   arg2 = (Dali::DrawMode::Type)jarg2;
30969   {
30970     try {
30971       (arg1)->SetDrawMode(arg2);
30972     } catch (std::out_of_range& e) {
30973       {
30974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30975       };
30976     } catch (std::exception& e) {
30977       {
30978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30979       };
30980     } catch (...) {
30981       {
30982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30983       };
30984     }
30985   }
30986 }
30987
30988
30989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
30990   int jresult ;
30991   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30992   Dali::DrawMode::Type result;
30993
30994   arg1 = (Dali::Actor *)jarg1;
30995   {
30996     try {
30997       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
30998     } catch (std::out_of_range& e) {
30999       {
31000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31001       };
31002     } catch (std::exception& e) {
31003       {
31004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31005       };
31006     } catch (...) {
31007       {
31008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31009       };
31010     }
31011   }
31012   jresult = (int)result;
31013   return jresult;
31014 }
31015
31016
31017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31019   bool arg2 ;
31020
31021   arg1 = (Dali::Actor *)jarg1;
31022   arg2 = jarg2 ? true : false;
31023   {
31024     try {
31025       (arg1)->SetSensitive(arg2);
31026     } catch (std::out_of_range& e) {
31027       {
31028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31029       };
31030     } catch (std::exception& e) {
31031       {
31032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31033       };
31034     } catch (...) {
31035       {
31036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31037       };
31038     }
31039   }
31040 }
31041
31042
31043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31044   unsigned int jresult ;
31045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31046   bool result;
31047
31048   arg1 = (Dali::Actor *)jarg1;
31049   {
31050     try {
31051       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31052     } catch (std::out_of_range& e) {
31053       {
31054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31055       };
31056     } catch (std::exception& e) {
31057       {
31058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31059       };
31060     } catch (...) {
31061       {
31062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31063       };
31064     }
31065   }
31066   jresult = result;
31067   return jresult;
31068 }
31069
31070
31071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31072   unsigned int jresult ;
31073   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31074   float *arg2 = 0 ;
31075   float *arg3 = 0 ;
31076   float arg4 ;
31077   float arg5 ;
31078   bool result;
31079
31080   arg1 = (Dali::Actor *)jarg1;
31081   arg2 = (float *)jarg2;
31082   arg3 = (float *)jarg3;
31083   arg4 = (float)jarg4;
31084   arg5 = (float)jarg5;
31085   {
31086     try {
31087       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31088     } catch (std::out_of_range& e) {
31089       {
31090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31091       };
31092     } catch (std::exception& e) {
31093       {
31094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31095       };
31096     } catch (...) {
31097       {
31098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31099       };
31100     }
31101   }
31102   jresult = result;
31103   return jresult;
31104 }
31105
31106
31107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31108   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31109   bool arg2 ;
31110
31111   arg1 = (Dali::Actor *)jarg1;
31112   arg2 = jarg2 ? true : false;
31113   {
31114     try {
31115       (arg1)->SetLeaveRequired(arg2);
31116     } catch (std::out_of_range& e) {
31117       {
31118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31119       };
31120     } catch (std::exception& e) {
31121       {
31122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31123       };
31124     } catch (...) {
31125       {
31126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31127       };
31128     }
31129   }
31130 }
31131
31132
31133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31134   unsigned int jresult ;
31135   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31136   bool result;
31137
31138   arg1 = (Dali::Actor *)jarg1;
31139   {
31140     try {
31141       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31142     } catch (std::out_of_range& e) {
31143       {
31144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31145       };
31146     } catch (std::exception& e) {
31147       {
31148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31149       };
31150     } catch (...) {
31151       {
31152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31153       };
31154     }
31155   }
31156   jresult = result;
31157   return jresult;
31158 }
31159
31160
31161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31162   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31163   bool arg2 ;
31164
31165   arg1 = (Dali::Actor *)jarg1;
31166   arg2 = jarg2 ? true : false;
31167   {
31168     try {
31169       (arg1)->SetKeyboardFocusable(arg2);
31170     } catch (std::out_of_range& e) {
31171       {
31172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31173       };
31174     } catch (std::exception& e) {
31175       {
31176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31177       };
31178     } catch (...) {
31179       {
31180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31181       };
31182     }
31183   }
31184 }
31185
31186
31187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31188   unsigned int jresult ;
31189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31190   bool result;
31191
31192   arg1 = (Dali::Actor *)jarg1;
31193   {
31194     try {
31195       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31196     } catch (std::out_of_range& e) {
31197       {
31198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31199       };
31200     } catch (std::exception& e) {
31201       {
31202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31203       };
31204     } catch (...) {
31205       {
31206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31207       };
31208     }
31209   }
31210   jresult = result;
31211   return jresult;
31212 }
31213
31214
31215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31217   Dali::ResizePolicy::Type arg2 ;
31218   Dali::Dimension::Type arg3 ;
31219
31220   arg1 = (Dali::Actor *)jarg1;
31221   arg2 = (Dali::ResizePolicy::Type)jarg2;
31222   arg3 = (Dali::Dimension::Type)jarg3;
31223   {
31224     try {
31225       (arg1)->SetResizePolicy(arg2,arg3);
31226     } catch (std::out_of_range& e) {
31227       {
31228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31229       };
31230     } catch (std::exception& e) {
31231       {
31232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31233       };
31234     } catch (...) {
31235       {
31236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31237       };
31238     }
31239   }
31240 }
31241
31242
31243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31244   int jresult ;
31245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31246   Dali::Dimension::Type arg2 ;
31247   Dali::ResizePolicy::Type result;
31248
31249   arg1 = (Dali::Actor *)jarg1;
31250   arg2 = (Dali::Dimension::Type)jarg2;
31251   {
31252     try {
31253       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31254     } catch (std::out_of_range& e) {
31255       {
31256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31257       };
31258     } catch (std::exception& e) {
31259       {
31260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31261       };
31262     } catch (...) {
31263       {
31264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31265       };
31266     }
31267   }
31268   jresult = (int)result;
31269   return jresult;
31270 }
31271
31272
31273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31275   Dali::SizeScalePolicy::Type arg2 ;
31276
31277   arg1 = (Dali::Actor *)jarg1;
31278   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31279   {
31280     try {
31281       (arg1)->SetSizeScalePolicy(arg2);
31282     } catch (std::out_of_range& e) {
31283       {
31284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31285       };
31286     } catch (std::exception& e) {
31287       {
31288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31289       };
31290     } catch (...) {
31291       {
31292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31293       };
31294     }
31295   }
31296 }
31297
31298
31299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31300   int jresult ;
31301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31302   Dali::SizeScalePolicy::Type result;
31303
31304   arg1 = (Dali::Actor *)jarg1;
31305   {
31306     try {
31307       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31308     } catch (std::out_of_range& e) {
31309       {
31310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31311       };
31312     } catch (std::exception& e) {
31313       {
31314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31315       };
31316     } catch (...) {
31317       {
31318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31319       };
31320     }
31321   }
31322   jresult = (int)result;
31323   return jresult;
31324 }
31325
31326
31327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31328   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31329   Dali::Vector3 *arg2 = 0 ;
31330
31331   arg1 = (Dali::Actor *)jarg1;
31332   arg2 = (Dali::Vector3 *)jarg2;
31333   if (!arg2) {
31334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31335     return ;
31336   }
31337   {
31338     try {
31339       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31340     } catch (std::out_of_range& e) {
31341       {
31342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31343       };
31344     } catch (std::exception& e) {
31345       {
31346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31347       };
31348     } catch (...) {
31349       {
31350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31351       };
31352     }
31353   }
31354 }
31355
31356
31357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31358   void * jresult ;
31359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31360   Dali::Vector3 result;
31361
31362   arg1 = (Dali::Actor *)jarg1;
31363   {
31364     try {
31365       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31366     } catch (std::out_of_range& e) {
31367       {
31368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31369       };
31370     } catch (std::exception& e) {
31371       {
31372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31373       };
31374     } catch (...) {
31375       {
31376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31377       };
31378     }
31379   }
31380   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31381   return jresult;
31382 }
31383
31384
31385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31386   float jresult ;
31387   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31388   float arg2 ;
31389   float result;
31390
31391   arg1 = (Dali::Actor *)jarg1;
31392   arg2 = (float)jarg2;
31393   {
31394     try {
31395       result = (float)(arg1)->GetHeightForWidth(arg2);
31396     } catch (std::out_of_range& e) {
31397       {
31398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31399       };
31400     } catch (std::exception& e) {
31401       {
31402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31403       };
31404     } catch (...) {
31405       {
31406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31407       };
31408     }
31409   }
31410   jresult = result;
31411   return jresult;
31412 }
31413
31414
31415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31416   float jresult ;
31417   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31418   float arg2 ;
31419   float result;
31420
31421   arg1 = (Dali::Actor *)jarg1;
31422   arg2 = (float)jarg2;
31423   {
31424     try {
31425       result = (float)(arg1)->GetWidthForHeight(arg2);
31426     } catch (std::out_of_range& e) {
31427       {
31428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31429       };
31430     } catch (std::exception& e) {
31431       {
31432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31433       };
31434     } catch (...) {
31435       {
31436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31437       };
31438     }
31439   }
31440   jresult = result;
31441   return jresult;
31442 }
31443
31444
31445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31446   float jresult ;
31447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31448   Dali::Dimension::Type arg2 ;
31449   float result;
31450
31451   arg1 = (Dali::Actor *)jarg1;
31452   arg2 = (Dali::Dimension::Type)jarg2;
31453   {
31454     try {
31455       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31456     } catch (std::out_of_range& e) {
31457       {
31458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31459       };
31460     } catch (std::exception& e) {
31461       {
31462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31463       };
31464     } catch (...) {
31465       {
31466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31467       };
31468     }
31469   }
31470   jresult = result;
31471   return jresult;
31472 }
31473
31474
31475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31477   Dali::Padding *arg2 = 0 ;
31478
31479   arg1 = (Dali::Actor *)jarg1;
31480   arg2 = (Dali::Padding *)jarg2;
31481   if (!arg2) {
31482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31483     return ;
31484   }
31485   {
31486     try {
31487       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31488     } catch (std::out_of_range& e) {
31489       {
31490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31491       };
31492     } catch (std::exception& e) {
31493       {
31494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31495       };
31496     } catch (...) {
31497       {
31498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31499       };
31500     }
31501   }
31502 }
31503
31504
31505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31506   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31507   Dali::Padding *arg2 = 0 ;
31508
31509   arg1 = (Dali::Actor *)jarg1;
31510   arg2 = (Dali::Padding *)jarg2;
31511   if (!arg2) {
31512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31513     return ;
31514   }
31515   {
31516     try {
31517       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31518     } catch (std::out_of_range& e) {
31519       {
31520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31521       };
31522     } catch (std::exception& e) {
31523       {
31524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31525       };
31526     } catch (...) {
31527       {
31528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31529       };
31530     }
31531   }
31532 }
31533
31534
31535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31537   Dali::Vector2 *arg2 = 0 ;
31538
31539   arg1 = (Dali::Actor *)jarg1;
31540   arg2 = (Dali::Vector2 *)jarg2;
31541   if (!arg2) {
31542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31543     return ;
31544   }
31545   {
31546     try {
31547       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31548     } catch (std::out_of_range& e) {
31549       {
31550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31551       };
31552     } catch (std::exception& e) {
31553       {
31554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31555       };
31556     } catch (...) {
31557       {
31558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31559       };
31560     }
31561   }
31562 }
31563
31564
31565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31566   void * jresult ;
31567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31568   Dali::Vector2 result;
31569
31570   arg1 = (Dali::Actor *)jarg1;
31571   {
31572     try {
31573       result = (arg1)->GetMinimumSize();
31574     } catch (std::out_of_range& e) {
31575       {
31576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31577       };
31578     } catch (std::exception& e) {
31579       {
31580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31581       };
31582     } catch (...) {
31583       {
31584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31585       };
31586     }
31587   }
31588   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31589   return jresult;
31590 }
31591
31592
31593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31594   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31595   Dali::Vector2 *arg2 = 0 ;
31596
31597   arg1 = (Dali::Actor *)jarg1;
31598   arg2 = (Dali::Vector2 *)jarg2;
31599   if (!arg2) {
31600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31601     return ;
31602   }
31603   {
31604     try {
31605       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31606     } catch (std::out_of_range& e) {
31607       {
31608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31609       };
31610     } catch (std::exception& e) {
31611       {
31612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31613       };
31614     } catch (...) {
31615       {
31616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31617       };
31618     }
31619   }
31620 }
31621
31622
31623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31624   void * jresult ;
31625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31626   Dali::Vector2 result;
31627
31628   arg1 = (Dali::Actor *)jarg1;
31629   {
31630     try {
31631       result = (arg1)->GetMaximumSize();
31632     } catch (std::out_of_range& e) {
31633       {
31634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31635       };
31636     } catch (std::exception& e) {
31637       {
31638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31639       };
31640     } catch (...) {
31641       {
31642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31643       };
31644     }
31645   }
31646   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31647   return jresult;
31648 }
31649
31650
31651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31652   int jresult ;
31653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31654   int result;
31655
31656   arg1 = (Dali::Actor *)jarg1;
31657   {
31658     try {
31659       result = (int)(arg1)->GetHierarchyDepth();
31660     } catch (std::out_of_range& e) {
31661       {
31662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31663       };
31664     } catch (std::exception& e) {
31665       {
31666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31667       };
31668     } catch (...) {
31669       {
31670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31671       };
31672     }
31673   }
31674   jresult = result;
31675   return jresult;
31676 }
31677
31678
31679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31680   unsigned int jresult ;
31681   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31682   Dali::Renderer *arg2 = 0 ;
31683   unsigned int result;
31684
31685   arg1 = (Dali::Actor *)jarg1;
31686   arg2 = (Dali::Renderer *)jarg2;
31687   if (!arg2) {
31688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31689     return 0;
31690   }
31691   {
31692     try {
31693       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31694     } catch (std::out_of_range& e) {
31695       {
31696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31697       };
31698     } catch (std::exception& e) {
31699       {
31700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31701       };
31702     } catch (...) {
31703       {
31704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31705       };
31706     }
31707   }
31708   jresult = result;
31709   return jresult;
31710 }
31711
31712
31713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
31714   unsigned int jresult ;
31715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31716   unsigned int result;
31717
31718   arg1 = (Dali::Actor *)jarg1;
31719   {
31720     try {
31721       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31722     } catch (std::out_of_range& e) {
31723       {
31724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31725       };
31726     } catch (std::exception& e) {
31727       {
31728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31729       };
31730     } catch (...) {
31731       {
31732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31733       };
31734     }
31735   }
31736   jresult = result;
31737   return jresult;
31738 }
31739
31740
31741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31742   void * jresult ;
31743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31744   unsigned int arg2 ;
31745   Dali::Renderer result;
31746
31747   arg1 = (Dali::Actor *)jarg1;
31748   arg2 = (unsigned int)jarg2;
31749   {
31750     try {
31751       result = (arg1)->GetRendererAt(arg2);
31752     } catch (std::out_of_range& e) {
31753       {
31754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31755       };
31756     } catch (std::exception& e) {
31757       {
31758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31759       };
31760     } catch (...) {
31761       {
31762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31763       };
31764     }
31765   }
31766   jresult = new Dali::Renderer((const Dali::Renderer &)result);
31767   return jresult;
31768 }
31769
31770
31771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
31772   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31773   Dali::Renderer *arg2 = 0 ;
31774
31775   arg1 = (Dali::Actor *)jarg1;
31776   arg2 = (Dali::Renderer *)jarg2;
31777   if (!arg2) {
31778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31779     return ;
31780   }
31781   {
31782     try {
31783       (arg1)->RemoveRenderer(*arg2);
31784     } catch (std::out_of_range& e) {
31785       {
31786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31787       };
31788     } catch (std::exception& e) {
31789       {
31790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31791       };
31792     } catch (...) {
31793       {
31794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31795       };
31796     }
31797   }
31798 }
31799
31800
31801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
31802   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31803   unsigned int arg2 ;
31804
31805   arg1 = (Dali::Actor *)jarg1;
31806   arg2 = (unsigned int)jarg2;
31807   {
31808     try {
31809       (arg1)->RemoveRenderer(arg2);
31810     } catch (std::out_of_range& e) {
31811       {
31812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31813       };
31814     } catch (std::exception& e) {
31815       {
31816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31817       };
31818     } catch (...) {
31819       {
31820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31821       };
31822     }
31823   }
31824 }
31825
31826
31827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
31828   void * jresult ;
31829   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31830   Dali::Actor::TouchSignalType *result = 0 ;
31831
31832   arg1 = (Dali::Actor *)jarg1;
31833   {
31834     try {
31835       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
31836     } catch (std::out_of_range& e) {
31837       {
31838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31839       };
31840     } catch (std::exception& e) {
31841       {
31842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31843       };
31844     } catch (...) {
31845       {
31846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31847       };
31848     }
31849   }
31850   jresult = (void *)result;
31851   return jresult;
31852 }
31853
31854
31855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
31856   void * jresult ;
31857   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31858   Dali::Actor::TouchDataSignalType *result = 0 ;
31859
31860   arg1 = (Dali::Actor *)jarg1;
31861   {
31862     try {
31863       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
31864     } catch (std::out_of_range& e) {
31865       {
31866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31867       };
31868     } catch (std::exception& e) {
31869       {
31870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (...) {
31873       {
31874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31875       };
31876     }
31877   }
31878   jresult = (void *)result;
31879   return jresult;
31880 }
31881
31882
31883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
31884   void * jresult ;
31885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31886   Dali::Actor::HoverSignalType *result = 0 ;
31887
31888   arg1 = (Dali::Actor *)jarg1;
31889   {
31890     try {
31891       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
31892     } catch (std::out_of_range& e) {
31893       {
31894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31895       };
31896     } catch (std::exception& e) {
31897       {
31898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31899       };
31900     } catch (...) {
31901       {
31902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31903       };
31904     }
31905   }
31906   jresult = (void *)result;
31907   return jresult;
31908 }
31909
31910
31911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
31912   void * jresult ;
31913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31914   Dali::Actor::WheelEventSignalType *result = 0 ;
31915
31916   arg1 = (Dali::Actor *)jarg1;
31917   {
31918     try {
31919       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
31920     } catch (std::out_of_range& e) {
31921       {
31922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31923       };
31924     } catch (std::exception& e) {
31925       {
31926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31927       };
31928     } catch (...) {
31929       {
31930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31931       };
31932     }
31933   }
31934   jresult = (void *)result;
31935   return jresult;
31936 }
31937
31938
31939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
31940   void * jresult ;
31941   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31942   Dali::Actor::OnStageSignalType *result = 0 ;
31943
31944   arg1 = (Dali::Actor *)jarg1;
31945   {
31946     try {
31947       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
31948     } catch (std::out_of_range& e) {
31949       {
31950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31951       };
31952     } catch (std::exception& e) {
31953       {
31954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31955       };
31956     } catch (...) {
31957       {
31958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31959       };
31960     }
31961   }
31962   jresult = (void *)result;
31963   return jresult;
31964 }
31965
31966
31967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
31968   void * jresult ;
31969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31970   Dali::Actor::OffStageSignalType *result = 0 ;
31971
31972   arg1 = (Dali::Actor *)jarg1;
31973   {
31974     try {
31975       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
31976     } catch (std::out_of_range& e) {
31977       {
31978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31979       };
31980     } catch (std::exception& e) {
31981       {
31982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31983       };
31984     } catch (...) {
31985       {
31986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31987       };
31988     }
31989   }
31990   jresult = (void *)result;
31991   return jresult;
31992 }
31993
31994
31995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
31996   void * jresult ;
31997   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31998   Dali::Actor::OnRelayoutSignalType *result = 0 ;
31999
32000   arg1 = (Dali::Actor *)jarg1;
32001   {
32002     try {
32003       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32004     } catch (std::out_of_range& e) {
32005       {
32006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32007       };
32008     } catch (std::exception& e) {
32009       {
32010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32011       };
32012     } catch (...) {
32013       {
32014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32015       };
32016     }
32017   }
32018   jresult = (void *)result;
32019   return jresult;
32020 }
32021
32022
32023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32024   Dali::Actor *arg1 = 0 ;
32025
32026   arg1 = (Dali::Actor *)jarg1;
32027   if (!arg1) {
32028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32029     return ;
32030   }
32031   {
32032     try {
32033       Dali::UnparentAndReset(*arg1);
32034     } catch (std::out_of_range& e) {
32035       {
32036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32037       };
32038     } catch (std::exception& e) {
32039       {
32040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32041       };
32042     } catch (...) {
32043       {
32044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32045       };
32046     }
32047   }
32048 }
32049
32050
32051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32052   int jresult ;
32053   int result;
32054
32055   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32056   jresult = (int)result;
32057   return jresult;
32058 }
32059
32060
32061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32062   int jresult ;
32063   int result;
32064
32065   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32066   jresult = (int)result;
32067   return jresult;
32068 }
32069
32070
32071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32072   int jresult ;
32073   int result;
32074
32075   result = (int)Dali::Layer::Property::BEHAVIOR;
32076   jresult = (int)result;
32077   return jresult;
32078 }
32079
32080
32081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32082   void * jresult ;
32083   Dali::Layer::Property *result = 0 ;
32084
32085   {
32086     try {
32087       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32088     } catch (std::out_of_range& e) {
32089       {
32090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32091       };
32092     } catch (std::exception& e) {
32093       {
32094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32095       };
32096     } catch (...) {
32097       {
32098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32099       };
32100     }
32101   }
32102   jresult = (void *)result;
32103   return jresult;
32104 }
32105
32106
32107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32108   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32109
32110   arg1 = (Dali::Layer::Property *)jarg1;
32111   {
32112     try {
32113       delete arg1;
32114     } catch (std::out_of_range& e) {
32115       {
32116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32117       };
32118     } catch (std::exception& e) {
32119       {
32120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32121       };
32122     } catch (...) {
32123       {
32124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32125       };
32126     }
32127   }
32128 }
32129
32130
32131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32132   void * jresult ;
32133   Dali::Layer *result = 0 ;
32134
32135   {
32136     try {
32137       result = (Dali::Layer *)new Dali::Layer();
32138     } catch (std::out_of_range& e) {
32139       {
32140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32141       };
32142     } catch (std::exception& e) {
32143       {
32144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32145       };
32146     } catch (...) {
32147       {
32148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32149       };
32150     }
32151   }
32152   jresult = (void *)result;
32153   return jresult;
32154 }
32155
32156
32157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32158   void * jresult ;
32159   Dali::Layer result;
32160
32161   {
32162     try {
32163       result = Dali::Layer::New();
32164     } catch (std::out_of_range& e) {
32165       {
32166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32167       };
32168     } catch (std::exception& e) {
32169       {
32170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32171       };
32172     } catch (...) {
32173       {
32174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32175       };
32176     }
32177   }
32178   jresult = new Dali::Layer((const Dali::Layer &)result);
32179   return jresult;
32180 }
32181
32182
32183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32184   void * jresult ;
32185   Dali::BaseHandle arg1 ;
32186   Dali::BaseHandle *argp1 ;
32187   Dali::Layer result;
32188
32189   argp1 = (Dali::BaseHandle *)jarg1;
32190   if (!argp1) {
32191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32192     return 0;
32193   }
32194   arg1 = *argp1;
32195   {
32196     try {
32197       result = Dali::Layer::DownCast(arg1);
32198     } catch (std::out_of_range& e) {
32199       {
32200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32201       };
32202     } catch (std::exception& e) {
32203       {
32204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32205       };
32206     } catch (...) {
32207       {
32208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32209       };
32210     }
32211   }
32212   jresult = new Dali::Layer((const Dali::Layer &)result);
32213   return jresult;
32214 }
32215
32216
32217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32218   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32219
32220   arg1 = (Dali::Layer *)jarg1;
32221   {
32222     try {
32223       delete arg1;
32224     } catch (std::out_of_range& e) {
32225       {
32226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32227       };
32228     } catch (std::exception& e) {
32229       {
32230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32231       };
32232     } catch (...) {
32233       {
32234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32235       };
32236     }
32237   }
32238 }
32239
32240
32241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32242   void * jresult ;
32243   Dali::Layer *arg1 = 0 ;
32244   Dali::Layer *result = 0 ;
32245
32246   arg1 = (Dali::Layer *)jarg1;
32247   if (!arg1) {
32248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32249     return 0;
32250   }
32251   {
32252     try {
32253       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32254     } catch (std::out_of_range& e) {
32255       {
32256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32257       };
32258     } catch (std::exception& e) {
32259       {
32260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32261       };
32262     } catch (...) {
32263       {
32264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32265       };
32266     }
32267   }
32268   jresult = (void *)result;
32269   return jresult;
32270 }
32271
32272
32273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32274   void * jresult ;
32275   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32276   Dali::Layer *arg2 = 0 ;
32277   Dali::Layer *result = 0 ;
32278
32279   arg1 = (Dali::Layer *)jarg1;
32280   arg2 = (Dali::Layer *)jarg2;
32281   if (!arg2) {
32282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32283     return 0;
32284   }
32285   {
32286     try {
32287       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32288     } catch (std::out_of_range& e) {
32289       {
32290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32291       };
32292     } catch (std::exception& e) {
32293       {
32294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32295       };
32296     } catch (...) {
32297       {
32298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32299       };
32300     }
32301   }
32302   jresult = (void *)result;
32303   return jresult;
32304 }
32305
32306
32307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32308   unsigned int jresult ;
32309   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32310   unsigned int result;
32311
32312   arg1 = (Dali::Layer *)jarg1;
32313   {
32314     try {
32315       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32316     } catch (std::out_of_range& e) {
32317       {
32318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32319       };
32320     } catch (std::exception& e) {
32321       {
32322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32323       };
32324     } catch (...) {
32325       {
32326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32327       };
32328     }
32329   }
32330   jresult = result;
32331   return jresult;
32332 }
32333
32334
32335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32336   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32337
32338   arg1 = (Dali::Layer *)jarg1;
32339   {
32340     try {
32341       (arg1)->Raise();
32342     } catch (std::out_of_range& e) {
32343       {
32344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32345       };
32346     } catch (std::exception& e) {
32347       {
32348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32349       };
32350     } catch (...) {
32351       {
32352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32353       };
32354     }
32355   }
32356 }
32357
32358
32359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32360   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32361
32362   arg1 = (Dali::Layer *)jarg1;
32363   {
32364     try {
32365       (arg1)->Lower();
32366     } catch (std::out_of_range& e) {
32367       {
32368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32369       };
32370     } catch (std::exception& e) {
32371       {
32372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32373       };
32374     } catch (...) {
32375       {
32376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32377       };
32378     }
32379   }
32380 }
32381
32382
32383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32384   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32385   Dali::Layer arg2 ;
32386   Dali::Layer *argp2 ;
32387
32388   arg1 = (Dali::Layer *)jarg1;
32389   argp2 = (Dali::Layer *)jarg2;
32390   if (!argp2) {
32391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32392     return ;
32393   }
32394   arg2 = *argp2;
32395   {
32396     try {
32397       (arg1)->RaiseAbove(arg2);
32398     } catch (std::out_of_range& e) {
32399       {
32400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32401       };
32402     } catch (std::exception& e) {
32403       {
32404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32405       };
32406     } catch (...) {
32407       {
32408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32409       };
32410     }
32411   }
32412 }
32413
32414
32415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32416   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32417   Dali::Layer arg2 ;
32418   Dali::Layer *argp2 ;
32419
32420   arg1 = (Dali::Layer *)jarg1;
32421   argp2 = (Dali::Layer *)jarg2;
32422   if (!argp2) {
32423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32424     return ;
32425   }
32426   arg2 = *argp2;
32427   {
32428     try {
32429       (arg1)->LowerBelow(arg2);
32430     } catch (std::out_of_range& e) {
32431       {
32432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32433       };
32434     } catch (std::exception& e) {
32435       {
32436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32437       };
32438     } catch (...) {
32439       {
32440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32441       };
32442     }
32443   }
32444 }
32445
32446
32447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32448   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32449
32450   arg1 = (Dali::Layer *)jarg1;
32451   {
32452     try {
32453       (arg1)->RaiseToTop();
32454     } catch (std::out_of_range& e) {
32455       {
32456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32457       };
32458     } catch (std::exception& e) {
32459       {
32460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32461       };
32462     } catch (...) {
32463       {
32464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32465       };
32466     }
32467   }
32468 }
32469
32470
32471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32472   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32473
32474   arg1 = (Dali::Layer *)jarg1;
32475   {
32476     try {
32477       (arg1)->LowerToBottom();
32478     } catch (std::out_of_range& e) {
32479       {
32480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32481       };
32482     } catch (std::exception& e) {
32483       {
32484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32485       };
32486     } catch (...) {
32487       {
32488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32489       };
32490     }
32491   }
32492 }
32493
32494
32495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32496   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32497   Dali::Layer arg2 ;
32498   Dali::Layer *argp2 ;
32499
32500   arg1 = (Dali::Layer *)jarg1;
32501   argp2 = (Dali::Layer *)jarg2;
32502   if (!argp2) {
32503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32504     return ;
32505   }
32506   arg2 = *argp2;
32507   {
32508     try {
32509       (arg1)->MoveAbove(arg2);
32510     } catch (std::out_of_range& e) {
32511       {
32512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32513       };
32514     } catch (std::exception& e) {
32515       {
32516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32517       };
32518     } catch (...) {
32519       {
32520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32521       };
32522     }
32523   }
32524 }
32525
32526
32527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32528   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32529   Dali::Layer arg2 ;
32530   Dali::Layer *argp2 ;
32531
32532   arg1 = (Dali::Layer *)jarg1;
32533   argp2 = (Dali::Layer *)jarg2;
32534   if (!argp2) {
32535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32536     return ;
32537   }
32538   arg2 = *argp2;
32539   {
32540     try {
32541       (arg1)->MoveBelow(arg2);
32542     } catch (std::out_of_range& e) {
32543       {
32544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32545       };
32546     } catch (std::exception& e) {
32547       {
32548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32549       };
32550     } catch (...) {
32551       {
32552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32553       };
32554     }
32555   }
32556 }
32557
32558
32559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32560   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32561   Dali::Layer::Behavior arg2 ;
32562
32563   arg1 = (Dali::Layer *)jarg1;
32564   arg2 = (Dali::Layer::Behavior)jarg2;
32565   {
32566     try {
32567       (arg1)->SetBehavior(arg2);
32568     } catch (std::out_of_range& e) {
32569       {
32570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32571       };
32572     } catch (std::exception& e) {
32573       {
32574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32575       };
32576     } catch (...) {
32577       {
32578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32579       };
32580     }
32581   }
32582 }
32583
32584
32585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32586   int jresult ;
32587   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32588   Dali::Layer::Behavior result;
32589
32590   arg1 = (Dali::Layer *)jarg1;
32591   {
32592     try {
32593       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32594     } catch (std::out_of_range& e) {
32595       {
32596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32597       };
32598     } catch (std::exception& e) {
32599       {
32600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32601       };
32602     } catch (...) {
32603       {
32604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32605       };
32606     }
32607   }
32608   jresult = (int)result;
32609   return jresult;
32610 }
32611
32612
32613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
32614   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32615   bool arg2 ;
32616
32617   arg1 = (Dali::Layer *)jarg1;
32618   arg2 = jarg2 ? true : false;
32619   {
32620     try {
32621       (arg1)->SetClipping(arg2);
32622     } catch (std::out_of_range& e) {
32623       {
32624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32625       };
32626     } catch (std::exception& e) {
32627       {
32628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32629       };
32630     } catch (...) {
32631       {
32632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32633       };
32634     }
32635   }
32636 }
32637
32638
32639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
32640   unsigned int jresult ;
32641   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32642   bool result;
32643
32644   arg1 = (Dali::Layer *)jarg1;
32645   {
32646     try {
32647       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
32648     } catch (std::out_of_range& e) {
32649       {
32650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32651       };
32652     } catch (std::exception& e) {
32653       {
32654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32655       };
32656     } catch (...) {
32657       {
32658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32659       };
32660     }
32661   }
32662   jresult = result;
32663   return jresult;
32664 }
32665
32666
32667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
32668   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32669   int arg2 ;
32670   int arg3 ;
32671   int arg4 ;
32672   int arg5 ;
32673
32674   arg1 = (Dali::Layer *)jarg1;
32675   arg2 = (int)jarg2;
32676   arg3 = (int)jarg3;
32677   arg4 = (int)jarg4;
32678   arg5 = (int)jarg5;
32679   {
32680     try {
32681       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
32682     } catch (std::out_of_range& e) {
32683       {
32684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32685       };
32686     } catch (std::exception& e) {
32687       {
32688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32689       };
32690     } catch (...) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32693       };
32694     }
32695   }
32696 }
32697
32698
32699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
32700   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32701   Dali::ClippingBox arg2 ;
32702   Dali::ClippingBox *argp2 ;
32703
32704   arg1 = (Dali::Layer *)jarg1;
32705   argp2 = (Dali::ClippingBox *)jarg2;
32706   if (!argp2) {
32707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
32708     return ;
32709   }
32710   arg2 = *argp2;
32711   {
32712     try {
32713       (arg1)->SetClippingBox(arg2);
32714     } catch (std::out_of_range& e) {
32715       {
32716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32717       };
32718     } catch (std::exception& e) {
32719       {
32720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32721       };
32722     } catch (...) {
32723       {
32724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32725       };
32726     }
32727   }
32728 }
32729
32730
32731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
32732   void * jresult ;
32733   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32734   Dali::ClippingBox result;
32735
32736   arg1 = (Dali::Layer *)jarg1;
32737   {
32738     try {
32739       result = ((Dali::Layer const *)arg1)->GetClippingBox();
32740     } catch (std::out_of_range& e) {
32741       {
32742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32743       };
32744     } catch (std::exception& e) {
32745       {
32746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32747       };
32748     } catch (...) {
32749       {
32750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32751       };
32752     }
32753   }
32754   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
32755   return jresult;
32756 }
32757
32758
32759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
32760   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32761   bool arg2 ;
32762
32763   arg1 = (Dali::Layer *)jarg1;
32764   arg2 = jarg2 ? true : false;
32765   {
32766     try {
32767       (arg1)->SetDepthTestDisabled(arg2);
32768     } catch (std::out_of_range& e) {
32769       {
32770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32771       };
32772     } catch (std::exception& e) {
32773       {
32774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32775       };
32776     } catch (...) {
32777       {
32778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32779       };
32780     }
32781   }
32782 }
32783
32784
32785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
32786   unsigned int jresult ;
32787   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32788   bool result;
32789
32790   arg1 = (Dali::Layer *)jarg1;
32791   {
32792     try {
32793       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
32794     } catch (std::out_of_range& e) {
32795       {
32796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32797       };
32798     } catch (std::exception& e) {
32799       {
32800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32801       };
32802     } catch (...) {
32803       {
32804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32805       };
32806     }
32807   }
32808   jresult = result;
32809   return jresult;
32810 }
32811
32812
32813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
32814   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32815   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
32816
32817   arg1 = (Dali::Layer *)jarg1;
32818   arg2 = (Dali::Layer::SortFunctionType)jarg2;
32819   {
32820     try {
32821       (arg1)->SetSortFunction(arg2);
32822     } catch (std::out_of_range& e) {
32823       {
32824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32825       };
32826     } catch (std::exception& e) {
32827       {
32828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32829       };
32830     } catch (...) {
32831       {
32832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32833       };
32834     }
32835   }
32836 }
32837
32838
32839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
32840   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32841   bool arg2 ;
32842
32843   arg1 = (Dali::Layer *)jarg1;
32844   arg2 = jarg2 ? true : false;
32845   {
32846     try {
32847       (arg1)->SetTouchConsumed(arg2);
32848     } catch (std::out_of_range& e) {
32849       {
32850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32851       };
32852     } catch (std::exception& e) {
32853       {
32854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32855       };
32856     } catch (...) {
32857       {
32858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32859       };
32860     }
32861   }
32862 }
32863
32864
32865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
32866   unsigned int jresult ;
32867   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32868   bool result;
32869
32870   arg1 = (Dali::Layer *)jarg1;
32871   {
32872     try {
32873       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
32874     } catch (std::out_of_range& e) {
32875       {
32876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32877       };
32878     } catch (std::exception& e) {
32879       {
32880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32881       };
32882     } catch (...) {
32883       {
32884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32885       };
32886     }
32887   }
32888   jresult = result;
32889   return jresult;
32890 }
32891
32892
32893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
32894   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32895   bool arg2 ;
32896
32897   arg1 = (Dali::Layer *)jarg1;
32898   arg2 = jarg2 ? true : false;
32899   {
32900     try {
32901       (arg1)->SetHoverConsumed(arg2);
32902     } catch (std::out_of_range& e) {
32903       {
32904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32905       };
32906     } catch (std::exception& e) {
32907       {
32908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32909       };
32910     } catch (...) {
32911       {
32912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32913       };
32914     }
32915   }
32916 }
32917
32918
32919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
32920   unsigned int jresult ;
32921   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32922   bool result;
32923
32924   arg1 = (Dali::Layer *)jarg1;
32925   {
32926     try {
32927       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
32928     } catch (std::out_of_range& e) {
32929       {
32930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32931       };
32932     } catch (std::exception& e) {
32933       {
32934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32935       };
32936     } catch (...) {
32937       {
32938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32939       };
32940     }
32941   }
32942   jresult = result;
32943   return jresult;
32944 }
32945
32946
32947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
32948   void * jresult ;
32949   Dali::Vector4 *result = 0 ;
32950
32951   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
32952   jresult = (void *)result;
32953   return jresult;
32954 }
32955
32956
32957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
32958   void * jresult ;
32959   Dali::Vector4 *result = 0 ;
32960
32961   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
32962   jresult = (void *)result;
32963   return jresult;
32964 }
32965
32966
32967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
32968   void * jresult ;
32969   Dali::Stage *result = 0 ;
32970
32971   {
32972     try {
32973       result = (Dali::Stage *)new Dali::Stage();
32974     } catch (std::out_of_range& e) {
32975       {
32976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32977       };
32978     } catch (std::exception& e) {
32979       {
32980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32981       };
32982     } catch (...) {
32983       {
32984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32985       };
32986     }
32987   }
32988   jresult = (void *)result;
32989   return jresult;
32990 }
32991
32992
32993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
32994   void * jresult ;
32995   Dali::Stage result;
32996
32997   {
32998     try {
32999       result = Dali::Stage::GetCurrent();
33000     } catch (std::out_of_range& e) {
33001       {
33002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33003       };
33004     } catch (std::exception& e) {
33005       {
33006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33007       };
33008     } catch (...) {
33009       {
33010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33011       };
33012     }
33013   }
33014   jresult = new Dali::Stage((const Dali::Stage &)result);
33015   return jresult;
33016 }
33017
33018
33019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33020   unsigned int jresult ;
33021   bool result;
33022
33023   {
33024     try {
33025       result = (bool)Dali::Stage::IsInstalled();
33026     } catch (std::out_of_range& e) {
33027       {
33028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33029       };
33030     } catch (std::exception& e) {
33031       {
33032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33033       };
33034     } catch (...) {
33035       {
33036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33037       };
33038     }
33039   }
33040   jresult = result;
33041   return jresult;
33042 }
33043
33044
33045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33046   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33047
33048   arg1 = (Dali::Stage *)jarg1;
33049   {
33050     try {
33051       delete arg1;
33052     } catch (std::out_of_range& e) {
33053       {
33054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33055       };
33056     } catch (std::exception& e) {
33057       {
33058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33059       };
33060     } catch (...) {
33061       {
33062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33063       };
33064     }
33065   }
33066 }
33067
33068
33069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33070   void * jresult ;
33071   Dali::Stage *arg1 = 0 ;
33072   Dali::Stage *result = 0 ;
33073
33074   arg1 = (Dali::Stage *)jarg1;
33075   if (!arg1) {
33076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33077     return 0;
33078   }
33079   {
33080     try {
33081       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33082     } catch (std::out_of_range& e) {
33083       {
33084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33085       };
33086     } catch (std::exception& e) {
33087       {
33088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33089       };
33090     } catch (...) {
33091       {
33092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33093       };
33094     }
33095   }
33096   jresult = (void *)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33102   void * jresult ;
33103   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33104   Dali::Stage *arg2 = 0 ;
33105   Dali::Stage *result = 0 ;
33106
33107   arg1 = (Dali::Stage *)jarg1;
33108   arg2 = (Dali::Stage *)jarg2;
33109   if (!arg2) {
33110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33111     return 0;
33112   }
33113   {
33114     try {
33115       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33116     } catch (std::out_of_range& e) {
33117       {
33118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33119       };
33120     } catch (std::exception& e) {
33121       {
33122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33123       };
33124     } catch (...) {
33125       {
33126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33127       };
33128     }
33129   }
33130   jresult = (void *)result;
33131   return jresult;
33132 }
33133
33134
33135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33136   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33137   Dali::Actor *arg2 = 0 ;
33138
33139   arg1 = (Dali::Stage *)jarg1;
33140   arg2 = (Dali::Actor *)jarg2;
33141   if (!arg2) {
33142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33143     return ;
33144   }
33145   {
33146     try {
33147       (arg1)->Add(*arg2);
33148     } catch (std::out_of_range& e) {
33149       {
33150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33151       };
33152     } catch (std::exception& e) {
33153       {
33154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33155       };
33156     } catch (...) {
33157       {
33158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33159       };
33160     }
33161   }
33162 }
33163
33164
33165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33166   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33167   Dali::Actor *arg2 = 0 ;
33168
33169   arg1 = (Dali::Stage *)jarg1;
33170   arg2 = (Dali::Actor *)jarg2;
33171   if (!arg2) {
33172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33173     return ;
33174   }
33175   {
33176     try {
33177       (arg1)->Remove(*arg2);
33178     } catch (std::out_of_range& e) {
33179       {
33180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33181       };
33182     } catch (std::exception& e) {
33183       {
33184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33185       };
33186     } catch (...) {
33187       {
33188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33189       };
33190     }
33191   }
33192 }
33193
33194
33195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33196   void * jresult ;
33197   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33198   Dali::Vector2 result;
33199
33200   arg1 = (Dali::Stage *)jarg1;
33201   {
33202     try {
33203       result = ((Dali::Stage const *)arg1)->GetSize();
33204     } catch (std::out_of_range& e) {
33205       {
33206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33207       };
33208     } catch (std::exception& e) {
33209       {
33210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33211       };
33212     } catch (...) {
33213       {
33214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33215       };
33216     }
33217   }
33218   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33219   return jresult;
33220 }
33221
33222
33223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33224   void * jresult ;
33225   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33226   Dali::RenderTaskList result;
33227
33228   arg1 = (Dali::Stage *)jarg1;
33229   {
33230     try {
33231       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33232     } catch (std::out_of_range& e) {
33233       {
33234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33235       };
33236     } catch (std::exception& e) {
33237       {
33238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33239       };
33240     } catch (...) {
33241       {
33242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33243       };
33244     }
33245   }
33246   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33252   unsigned int jresult ;
33253   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33254   unsigned int result;
33255
33256   arg1 = (Dali::Stage *)jarg1;
33257   {
33258     try {
33259       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33260     } catch (std::out_of_range& e) {
33261       {
33262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33263       };
33264     } catch (std::exception& e) {
33265       {
33266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33267       };
33268     } catch (...) {
33269       {
33270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33271       };
33272     }
33273   }
33274   jresult = result;
33275   return jresult;
33276 }
33277
33278
33279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33280   void * jresult ;
33281   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33282   unsigned int arg2 ;
33283   Dali::Layer result;
33284
33285   arg1 = (Dali::Stage *)jarg1;
33286   arg2 = (unsigned int)jarg2;
33287   {
33288     try {
33289       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33290     } catch (std::out_of_range& e) {
33291       {
33292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33293       };
33294     } catch (std::exception& e) {
33295       {
33296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33297       };
33298     } catch (...) {
33299       {
33300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33301       };
33302     }
33303   }
33304   jresult = new Dali::Layer((const Dali::Layer &)result);
33305   return jresult;
33306 }
33307
33308
33309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33310   void * jresult ;
33311   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33312   Dali::Layer result;
33313
33314   arg1 = (Dali::Stage *)jarg1;
33315   {
33316     try {
33317       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33318     } catch (std::out_of_range& e) {
33319       {
33320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33321       };
33322     } catch (std::exception& e) {
33323       {
33324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33325       };
33326     } catch (...) {
33327       {
33328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33329       };
33330     }
33331   }
33332   jresult = new Dali::Layer((const Dali::Layer &)result);
33333   return jresult;
33334 }
33335
33336
33337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33338   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33339   Dali::Vector4 arg2 ;
33340   Dali::Vector4 *argp2 ;
33341
33342   arg1 = (Dali::Stage *)jarg1;
33343   argp2 = (Dali::Vector4 *)jarg2;
33344   if (!argp2) {
33345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33346     return ;
33347   }
33348   arg2 = *argp2;
33349   {
33350     try {
33351       (arg1)->SetBackgroundColor(arg2);
33352     } catch (std::out_of_range& e) {
33353       {
33354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33355       };
33356     } catch (std::exception& e) {
33357       {
33358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33359       };
33360     } catch (...) {
33361       {
33362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33363       };
33364     }
33365   }
33366 }
33367
33368
33369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33370   void * jresult ;
33371   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33372   Dali::Vector4 result;
33373
33374   arg1 = (Dali::Stage *)jarg1;
33375   {
33376     try {
33377       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33378     } catch (std::out_of_range& e) {
33379       {
33380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33381       };
33382     } catch (std::exception& e) {
33383       {
33384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33385       };
33386     } catch (...) {
33387       {
33388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33389       };
33390     }
33391   }
33392   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33393   return jresult;
33394 }
33395
33396
33397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33398   void * jresult ;
33399   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33400   Dali::Vector2 result;
33401
33402   arg1 = (Dali::Stage *)jarg1;
33403   {
33404     try {
33405       result = ((Dali::Stage const *)arg1)->GetDpi();
33406     } catch (std::out_of_range& e) {
33407       {
33408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33409       };
33410     } catch (std::exception& e) {
33411       {
33412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33413       };
33414     } catch (...) {
33415       {
33416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33417       };
33418     }
33419   }
33420   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33421   return jresult;
33422 }
33423
33424
33425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33426   void * jresult ;
33427   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33428   Dali::ObjectRegistry result;
33429
33430   arg1 = (Dali::Stage *)jarg1;
33431   {
33432     try {
33433       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33434     } catch (std::out_of_range& e) {
33435       {
33436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33437       };
33438     } catch (std::exception& e) {
33439       {
33440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33441       };
33442     } catch (...) {
33443       {
33444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33445       };
33446     }
33447   }
33448   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33449   return jresult;
33450 }
33451
33452
33453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33454   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33455   float arg2 ;
33456
33457   arg1 = (Dali::Stage *)jarg1;
33458   arg2 = (float)jarg2;
33459   {
33460     try {
33461       (arg1)->KeepRendering(arg2);
33462     } catch (std::out_of_range& e) {
33463       {
33464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33465       };
33466     } catch (std::exception& e) {
33467       {
33468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33469       };
33470     } catch (...) {
33471       {
33472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33473       };
33474     }
33475   }
33476 }
33477
33478
33479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33480   void * jresult ;
33481   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33482   Dali::Stage::KeyEventSignalType *result = 0 ;
33483
33484   arg1 = (Dali::Stage *)jarg1;
33485   {
33486     try {
33487       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33488     } catch (std::out_of_range& e) {
33489       {
33490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33491       };
33492     } catch (std::exception& e) {
33493       {
33494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33495       };
33496     } catch (...) {
33497       {
33498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33499       };
33500     }
33501   }
33502   jresult = (void *)result;
33503   return jresult;
33504 }
33505
33506
33507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33508   void * jresult ;
33509   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33510   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33511
33512   arg1 = (Dali::Stage *)jarg1;
33513   {
33514     try {
33515       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33516     } catch (std::out_of_range& e) {
33517       {
33518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33519       };
33520     } catch (std::exception& e) {
33521       {
33522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33523       };
33524     } catch (...) {
33525       {
33526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33527       };
33528     }
33529   }
33530   jresult = (void *)result;
33531   return jresult;
33532 }
33533
33534
33535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33536   void * jresult ;
33537   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33538   Dali::Stage::TouchSignalType *result = 0 ;
33539
33540   arg1 = (Dali::Stage *)jarg1;
33541   {
33542     try {
33543       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33544     } catch (std::out_of_range& e) {
33545       {
33546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33547       };
33548     } catch (std::exception& e) {
33549       {
33550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33551       };
33552     } catch (...) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33555       };
33556     }
33557   }
33558   jresult = (void *)result;
33559   return jresult;
33560 }
33561
33562
33563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33564   void * jresult ;
33565   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33566   Dali::Stage::WheelEventSignalType *result = 0 ;
33567
33568   arg1 = (Dali::Stage *)jarg1;
33569   {
33570     try {
33571       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33572     } catch (std::out_of_range& e) {
33573       {
33574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33575       };
33576     } catch (std::exception& e) {
33577       {
33578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33579       };
33580     } catch (...) {
33581       {
33582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33583       };
33584     }
33585   }
33586   jresult = (void *)result;
33587   return jresult;
33588 }
33589
33590
33591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33592   void * jresult ;
33593   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33594   Dali::Stage::ContextStatusSignal *result = 0 ;
33595
33596   arg1 = (Dali::Stage *)jarg1;
33597   {
33598     try {
33599       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33600     } catch (std::out_of_range& e) {
33601       {
33602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33603       };
33604     } catch (std::exception& e) {
33605       {
33606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33607       };
33608     } catch (...) {
33609       {
33610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33611       };
33612     }
33613   }
33614   jresult = (void *)result;
33615   return jresult;
33616 }
33617
33618
33619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
33620   void * jresult ;
33621   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33622   Dali::Stage::ContextStatusSignal *result = 0 ;
33623
33624   arg1 = (Dali::Stage *)jarg1;
33625   {
33626     try {
33627       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
33628     } catch (std::out_of_range& e) {
33629       {
33630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33631       };
33632     } catch (std::exception& e) {
33633       {
33634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33635       };
33636     } catch (...) {
33637       {
33638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33639       };
33640     }
33641   }
33642   jresult = (void *)result;
33643   return jresult;
33644 }
33645
33646
33647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
33648   void * jresult ;
33649   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33650   Dali::Stage::SceneCreatedSignalType *result = 0 ;
33651
33652   arg1 = (Dali::Stage *)jarg1;
33653   {
33654     try {
33655       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
33656     } catch (std::out_of_range& e) {
33657       {
33658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33659       };
33660     } catch (std::exception& e) {
33661       {
33662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33663       };
33664     } catch (...) {
33665       {
33666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33667       };
33668     }
33669   }
33670   jresult = (void *)result;
33671   return jresult;
33672 }
33673
33674
33675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
33676   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33677
33678   arg1 = (Dali::RelayoutContainer *)jarg1;
33679   {
33680     try {
33681       delete arg1;
33682     } catch (std::out_of_range& e) {
33683       {
33684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33685       };
33686     } catch (std::exception& e) {
33687       {
33688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33689       };
33690     } catch (...) {
33691       {
33692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33693       };
33694     }
33695   }
33696 }
33697
33698
33699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
33700   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33701   Dali::Actor *arg2 = 0 ;
33702   Dali::Vector2 *arg3 = 0 ;
33703
33704   arg1 = (Dali::RelayoutContainer *)jarg1;
33705   arg2 = (Dali::Actor *)jarg2;
33706   if (!arg2) {
33707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33708     return ;
33709   }
33710   arg3 = (Dali::Vector2 *)jarg3;
33711   if (!arg3) {
33712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
33713     return ;
33714   }
33715   {
33716     try {
33717       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
33718     } catch (std::out_of_range& e) {
33719       {
33720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33721       };
33722     } catch (std::exception& e) {
33723       {
33724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33725       };
33726     } catch (...) {
33727       {
33728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33729       };
33730     }
33731   }
33732 }
33733
33734
33735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
33736   void * jresult ;
33737   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33738   Dali::CustomActor result;
33739
33740   arg1 = (Dali::CustomActorImpl *)jarg1;
33741   {
33742     try {
33743       result = ((Dali::CustomActorImpl const *)arg1)->Self();
33744     } catch (std::out_of_range& e) {
33745       {
33746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33747       };
33748     } catch (std::exception& e) {
33749       {
33750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33751       };
33752     } catch (...) {
33753       {
33754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33755       };
33756     }
33757   }
33758   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
33759   return jresult;
33760 }
33761
33762
33763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
33764   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33765   int arg2 ;
33766
33767   arg1 = (Dali::CustomActorImpl *)jarg1;
33768   arg2 = (int)jarg2;
33769   {
33770     try {
33771       (arg1)->OnStageConnection(arg2);
33772     } catch (std::out_of_range& e) {
33773       {
33774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33775       };
33776     } catch (std::exception& e) {
33777       {
33778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33779       };
33780     } catch (...) {
33781       {
33782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33783       };
33784     }
33785   }
33786 }
33787
33788
33789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
33790   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33791
33792   arg1 = (Dali::CustomActorImpl *)jarg1;
33793   {
33794     try {
33795       (arg1)->OnStageDisconnection();
33796     } catch (std::out_of_range& e) {
33797       {
33798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33799       };
33800     } catch (std::exception& e) {
33801       {
33802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33803       };
33804     } catch (...) {
33805       {
33806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33807       };
33808     }
33809   }
33810 }
33811
33812
33813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
33814   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33815   Dali::Actor *arg2 = 0 ;
33816
33817   arg1 = (Dali::CustomActorImpl *)jarg1;
33818   arg2 = (Dali::Actor *)jarg2;
33819   if (!arg2) {
33820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33821     return ;
33822   }
33823   {
33824     try {
33825       (arg1)->OnChildAdd(*arg2);
33826     } catch (std::out_of_range& e) {
33827       {
33828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33829       };
33830     } catch (std::exception& e) {
33831       {
33832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33833       };
33834     } catch (...) {
33835       {
33836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33837       };
33838     }
33839   }
33840 }
33841
33842
33843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
33844   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33845   Dali::Actor *arg2 = 0 ;
33846
33847   arg1 = (Dali::CustomActorImpl *)jarg1;
33848   arg2 = (Dali::Actor *)jarg2;
33849   if (!arg2) {
33850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33851     return ;
33852   }
33853   {
33854     try {
33855       (arg1)->OnChildRemove(*arg2);
33856     } catch (std::out_of_range& e) {
33857       {
33858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33859       };
33860     } catch (std::exception& e) {
33861       {
33862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33863       };
33864     } catch (...) {
33865       {
33866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33867       };
33868     }
33869   }
33870 }
33871
33872
33873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
33874   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33875   Dali::Property::Index arg2 ;
33876   Dali::Property::Value arg3 ;
33877   Dali::Property::Value *argp3 ;
33878
33879   arg1 = (Dali::CustomActorImpl *)jarg1;
33880   arg2 = (Dali::Property::Index)jarg2;
33881   argp3 = (Dali::Property::Value *)jarg3;
33882   if (!argp3) {
33883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
33884     return ;
33885   }
33886   arg3 = *argp3;
33887   {
33888     try {
33889       (arg1)->OnPropertySet(arg2,arg3);
33890     } catch (std::out_of_range& e) {
33891       {
33892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33893       };
33894     } catch (std::exception& e) {
33895       {
33896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33897       };
33898     } catch (...) {
33899       {
33900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33901       };
33902     }
33903   }
33904 }
33905
33906
33907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
33908   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33909   Dali::Vector3 *arg2 = 0 ;
33910
33911   arg1 = (Dali::CustomActorImpl *)jarg1;
33912   arg2 = (Dali::Vector3 *)jarg2;
33913   if (!arg2) {
33914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33915     return ;
33916   }
33917   {
33918     try {
33919       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
33920     } catch (std::out_of_range& e) {
33921       {
33922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33923       };
33924     } catch (std::exception& e) {
33925       {
33926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33927       };
33928     } catch (...) {
33929       {
33930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33931       };
33932     }
33933   }
33934 }
33935
33936
33937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
33938   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33939   Dali::Animation *arg2 = 0 ;
33940   Dali::Vector3 *arg3 = 0 ;
33941
33942   arg1 = (Dali::CustomActorImpl *)jarg1;
33943   arg2 = (Dali::Animation *)jarg2;
33944   if (!arg2) {
33945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
33946     return ;
33947   }
33948   arg3 = (Dali::Vector3 *)jarg3;
33949   if (!arg3) {
33950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33951     return ;
33952   }
33953   {
33954     try {
33955       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
33956     } catch (std::out_of_range& e) {
33957       {
33958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33959       };
33960     } catch (std::exception& e) {
33961       {
33962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33963       };
33964     } catch (...) {
33965       {
33966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33967       };
33968     }
33969   }
33970 }
33971
33972
33973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
33974   unsigned int jresult ;
33975   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33976   Dali::TouchEvent *arg2 = 0 ;
33977   bool result;
33978
33979   arg1 = (Dali::CustomActorImpl *)jarg1;
33980   arg2 = (Dali::TouchEvent *)jarg2;
33981   if (!arg2) {
33982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
33983     return 0;
33984   }
33985   {
33986     try {
33987       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
33988     } catch (std::out_of_range& e) {
33989       {
33990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33991       };
33992     } catch (std::exception& e) {
33993       {
33994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33995       };
33996     } catch (...) {
33997       {
33998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33999       };
34000     }
34001   }
34002   jresult = result;
34003   return jresult;
34004 }
34005
34006
34007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34008   unsigned int jresult ;
34009   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34010   Dali::HoverEvent *arg2 = 0 ;
34011   bool result;
34012
34013   arg1 = (Dali::CustomActorImpl *)jarg1;
34014   arg2 = (Dali::HoverEvent *)jarg2;
34015   if (!arg2) {
34016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34017     return 0;
34018   }
34019   {
34020     try {
34021       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34022     } catch (std::out_of_range& e) {
34023       {
34024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34025       };
34026     } catch (std::exception& e) {
34027       {
34028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34029       };
34030     } catch (...) {
34031       {
34032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34033       };
34034     }
34035   }
34036   jresult = result;
34037   return jresult;
34038 }
34039
34040
34041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34042   unsigned int jresult ;
34043   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34044   Dali::KeyEvent *arg2 = 0 ;
34045   bool result;
34046
34047   arg1 = (Dali::CustomActorImpl *)jarg1;
34048   arg2 = (Dali::KeyEvent *)jarg2;
34049   if (!arg2) {
34050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34051     return 0;
34052   }
34053   {
34054     try {
34055       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34056     } catch (std::out_of_range& e) {
34057       {
34058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34059       };
34060     } catch (std::exception& e) {
34061       {
34062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34063       };
34064     } catch (...) {
34065       {
34066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34067       };
34068     }
34069   }
34070   jresult = result;
34071   return jresult;
34072 }
34073
34074
34075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34076   unsigned int jresult ;
34077   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34078   Dali::WheelEvent *arg2 = 0 ;
34079   bool result;
34080
34081   arg1 = (Dali::CustomActorImpl *)jarg1;
34082   arg2 = (Dali::WheelEvent *)jarg2;
34083   if (!arg2) {
34084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34085     return 0;
34086   }
34087   {
34088     try {
34089       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34090     } catch (std::out_of_range& e) {
34091       {
34092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34093       };
34094     } catch (std::exception& e) {
34095       {
34096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34097       };
34098     } catch (...) {
34099       {
34100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34101       };
34102     }
34103   }
34104   jresult = result;
34105   return jresult;
34106 }
34107
34108
34109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34110   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34111   Dali::Vector2 *arg2 = 0 ;
34112   Dali::RelayoutContainer *arg3 = 0 ;
34113
34114   arg1 = (Dali::CustomActorImpl *)jarg1;
34115   arg2 = (Dali::Vector2 *)jarg2;
34116   if (!arg2) {
34117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34118     return ;
34119   }
34120   arg3 = (Dali::RelayoutContainer *)jarg3;
34121   if (!arg3) {
34122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34123     return ;
34124   }
34125   {
34126     try {
34127       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34128     } catch (std::out_of_range& e) {
34129       {
34130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34131       };
34132     } catch (std::exception& e) {
34133       {
34134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34135       };
34136     } catch (...) {
34137       {
34138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34139       };
34140     }
34141   }
34142 }
34143
34144
34145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34146   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34147   Dali::ResizePolicy::Type arg2 ;
34148   Dali::Dimension::Type arg3 ;
34149
34150   arg1 = (Dali::CustomActorImpl *)jarg1;
34151   arg2 = (Dali::ResizePolicy::Type)jarg2;
34152   arg3 = (Dali::Dimension::Type)jarg3;
34153   {
34154     try {
34155       (arg1)->OnSetResizePolicy(arg2,arg3);
34156     } catch (std::out_of_range& e) {
34157       {
34158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34159       };
34160     } catch (std::exception& e) {
34161       {
34162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34163       };
34164     } catch (...) {
34165       {
34166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34167       };
34168     }
34169   }
34170 }
34171
34172
34173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34174   void * jresult ;
34175   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34176   Dali::Vector3 result;
34177
34178   arg1 = (Dali::CustomActorImpl *)jarg1;
34179   {
34180     try {
34181       result = (arg1)->GetNaturalSize();
34182     } catch (std::out_of_range& e) {
34183       {
34184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34185       };
34186     } catch (std::exception& e) {
34187       {
34188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34189       };
34190     } catch (...) {
34191       {
34192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34193       };
34194     }
34195   }
34196   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34197   return jresult;
34198 }
34199
34200
34201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34202   float jresult ;
34203   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34204   Dali::Actor *arg2 = 0 ;
34205   Dali::Dimension::Type arg3 ;
34206   float result;
34207
34208   arg1 = (Dali::CustomActorImpl *)jarg1;
34209   arg2 = (Dali::Actor *)jarg2;
34210   if (!arg2) {
34211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34212     return 0;
34213   }
34214   arg3 = (Dali::Dimension::Type)jarg3;
34215   {
34216     try {
34217       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34218     } catch (std::out_of_range& e) {
34219       {
34220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34221       };
34222     } catch (std::exception& e) {
34223       {
34224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34225       };
34226     } catch (...) {
34227       {
34228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34229       };
34230     }
34231   }
34232   jresult = result;
34233   return jresult;
34234 }
34235
34236
34237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34238   float jresult ;
34239   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34240   float arg2 ;
34241   float result;
34242
34243   arg1 = (Dali::CustomActorImpl *)jarg1;
34244   arg2 = (float)jarg2;
34245   {
34246     try {
34247       result = (float)(arg1)->GetHeightForWidth(arg2);
34248     } catch (std::out_of_range& e) {
34249       {
34250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34251       };
34252     } catch (std::exception& e) {
34253       {
34254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34255       };
34256     } catch (...) {
34257       {
34258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34259       };
34260     }
34261   }
34262   jresult = result;
34263   return jresult;
34264 }
34265
34266
34267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34268   float jresult ;
34269   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34270   float arg2 ;
34271   float result;
34272
34273   arg1 = (Dali::CustomActorImpl *)jarg1;
34274   arg2 = (float)jarg2;
34275   {
34276     try {
34277       result = (float)(arg1)->GetWidthForHeight(arg2);
34278     } catch (std::out_of_range& e) {
34279       {
34280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34281       };
34282     } catch (std::exception& e) {
34283       {
34284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34285       };
34286     } catch (...) {
34287       {
34288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34289       };
34290     }
34291   }
34292   jresult = result;
34293   return jresult;
34294 }
34295
34296
34297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34298   unsigned int jresult ;
34299   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34300   Dali::Dimension::Type arg2 ;
34301   bool result;
34302
34303   arg1 = (Dali::CustomActorImpl *)jarg1;
34304   arg2 = (Dali::Dimension::Type)jarg2;
34305   {
34306     try {
34307       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34308     } catch (std::out_of_range& e) {
34309       {
34310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34311       };
34312     } catch (std::exception& e) {
34313       {
34314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34315       };
34316     } catch (...) {
34317       {
34318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34319       };
34320     }
34321   }
34322   jresult = result;
34323   return jresult;
34324 }
34325
34326
34327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34328   unsigned int jresult ;
34329   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34330   bool result;
34331
34332   arg1 = (Dali::CustomActorImpl *)jarg1;
34333   {
34334     try {
34335       result = (bool)(arg1)->RelayoutDependentOnChildren();
34336     } catch (std::out_of_range& e) {
34337       {
34338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34339       };
34340     } catch (std::exception& e) {
34341       {
34342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34343       };
34344     } catch (...) {
34345       {
34346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34347       };
34348     }
34349   }
34350   jresult = result;
34351   return jresult;
34352 }
34353
34354
34355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34356   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34357   Dali::Dimension::Type arg2 ;
34358
34359   arg1 = (Dali::CustomActorImpl *)jarg1;
34360   arg2 = (Dali::Dimension::Type)jarg2;
34361   {
34362     try {
34363       (arg1)->OnCalculateRelayoutSize(arg2);
34364     } catch (std::out_of_range& e) {
34365       {
34366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34367       };
34368     } catch (std::exception& e) {
34369       {
34370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34371       };
34372     } catch (...) {
34373       {
34374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34375       };
34376     }
34377   }
34378 }
34379
34380
34381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34382   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34383   float arg2 ;
34384   Dali::Dimension::Type arg3 ;
34385
34386   arg1 = (Dali::CustomActorImpl *)jarg1;
34387   arg2 = (float)jarg2;
34388   arg3 = (Dali::Dimension::Type)jarg3;
34389   {
34390     try {
34391       (arg1)->OnLayoutNegotiated(arg2,arg3);
34392     } catch (std::out_of_range& e) {
34393       {
34394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34395       };
34396     } catch (std::exception& e) {
34397       {
34398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34399       };
34400     } catch (...) {
34401       {
34402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34403       };
34404     }
34405   }
34406 }
34407
34408
34409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34410   unsigned int jresult ;
34411   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34412   bool result;
34413
34414   arg1 = (Dali::CustomActorImpl *)jarg1;
34415   {
34416     try {
34417       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34418     } catch (std::out_of_range& e) {
34419       {
34420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34421       };
34422     } catch (std::exception& e) {
34423       {
34424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34425       };
34426     } catch (...) {
34427       {
34428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34429       };
34430     }
34431   }
34432   jresult = result;
34433   return jresult;
34434 }
34435
34436
34437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34438   unsigned int jresult ;
34439   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34440   bool result;
34441
34442   arg1 = (Dali::CustomActorImpl *)jarg1;
34443   {
34444     try {
34445       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34446     } catch (std::out_of_range& e) {
34447       {
34448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34449       };
34450     } catch (std::exception& e) {
34451       {
34452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34453       };
34454     } catch (...) {
34455       {
34456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34457       };
34458     }
34459   }
34460   jresult = result;
34461   return jresult;
34462 }
34463
34464
34465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34466   unsigned int jresult ;
34467   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34468   bool result;
34469
34470   arg1 = (Dali::CustomActorImpl *)jarg1;
34471   {
34472     try {
34473       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34474     } catch (std::out_of_range& e) {
34475       {
34476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34477       };
34478     } catch (std::exception& e) {
34479       {
34480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34481       };
34482     } catch (...) {
34483       {
34484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34485       };
34486     }
34487   }
34488   jresult = result;
34489   return jresult;
34490 }
34491
34492
34493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34494   unsigned int jresult ;
34495   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34496   bool result;
34497
34498   arg1 = (Dali::CustomActorImpl *)jarg1;
34499   {
34500     try {
34501       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34502     } catch (std::out_of_range& e) {
34503       {
34504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34505       };
34506     } catch (std::exception& e) {
34507       {
34508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34509       };
34510     } catch (...) {
34511       {
34512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34513       };
34514     }
34515   }
34516   jresult = result;
34517   return jresult;
34518 }
34519
34520
34521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34522   void * jresult ;
34523   Dali::CustomActor *result = 0 ;
34524
34525   {
34526     try {
34527       result = (Dali::CustomActor *)new Dali::CustomActor();
34528     } catch (std::out_of_range& e) {
34529       {
34530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34531       };
34532     } catch (std::exception& e) {
34533       {
34534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34535       };
34536     } catch (...) {
34537       {
34538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34539       };
34540     }
34541   }
34542   jresult = (void *)result;
34543   return jresult;
34544 }
34545
34546
34547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34548   void * jresult ;
34549   Dali::BaseHandle arg1 ;
34550   Dali::BaseHandle *argp1 ;
34551   Dali::CustomActor result;
34552
34553   argp1 = (Dali::BaseHandle *)jarg1;
34554   if (!argp1) {
34555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34556     return 0;
34557   }
34558   arg1 = *argp1;
34559   {
34560     try {
34561       result = Dali::CustomActor::DownCast(arg1);
34562     } catch (std::out_of_range& e) {
34563       {
34564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34565       };
34566     } catch (std::exception& e) {
34567       {
34568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34569       };
34570     } catch (...) {
34571       {
34572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34573       };
34574     }
34575   }
34576   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34577   return jresult;
34578 }
34579
34580
34581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34582   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34583
34584   arg1 = (Dali::CustomActor *)jarg1;
34585   {
34586     try {
34587       delete arg1;
34588     } catch (std::out_of_range& e) {
34589       {
34590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34591       };
34592     } catch (std::exception& e) {
34593       {
34594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34595       };
34596     } catch (...) {
34597       {
34598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34599       };
34600     }
34601   }
34602 }
34603
34604
34605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
34606   void * jresult ;
34607   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34608   Dali::CustomActorImpl *result = 0 ;
34609
34610   arg1 = (Dali::CustomActor *)jarg1;
34611   {
34612     try {
34613       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
34614     } catch (std::out_of_range& e) {
34615       {
34616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34617       };
34618     } catch (std::exception& e) {
34619       {
34620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34621       };
34622     } catch (...) {
34623       {
34624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34625       };
34626     }
34627   }
34628   jresult = (void *)result;
34629   return jresult;
34630 }
34631
34632
34633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
34634   void * jresult ;
34635   Dali::CustomActorImpl *arg1 = 0 ;
34636   Dali::CustomActor *result = 0 ;
34637
34638   arg1 = (Dali::CustomActorImpl *)jarg1;
34639   if (!arg1) {
34640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
34641     return 0;
34642   }
34643   {
34644     try {
34645       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
34646     } catch (std::out_of_range& e) {
34647       {
34648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34649       };
34650     } catch (std::exception& e) {
34651       {
34652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34653       };
34654     } catch (...) {
34655       {
34656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34657       };
34658     }
34659   }
34660   jresult = (void *)result;
34661   return jresult;
34662 }
34663
34664
34665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
34666   void * jresult ;
34667   Dali::CustomActor *arg1 = 0 ;
34668   Dali::CustomActor *result = 0 ;
34669
34670   arg1 = (Dali::CustomActor *)jarg1;
34671   if (!arg1) {
34672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34673     return 0;
34674   }
34675   {
34676     try {
34677       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
34678     } catch (std::out_of_range& e) {
34679       {
34680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34681       };
34682     } catch (std::exception& e) {
34683       {
34684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34685       };
34686     } catch (...) {
34687       {
34688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34689       };
34690     }
34691   }
34692   jresult = (void *)result;
34693   return jresult;
34694 }
34695
34696
34697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
34698   void * jresult ;
34699   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34700   Dali::CustomActor *arg2 = 0 ;
34701   Dali::CustomActor *result = 0 ;
34702
34703   arg1 = (Dali::CustomActor *)jarg1;
34704   arg2 = (Dali::CustomActor *)jarg2;
34705   if (!arg2) {
34706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34707     return 0;
34708   }
34709   {
34710     try {
34711       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
34712     } catch (std::out_of_range& e) {
34713       {
34714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34715       };
34716     } catch (std::exception& e) {
34717       {
34718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34719       };
34720     } catch (...) {
34721       {
34722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34723       };
34724     }
34725   }
34726   jresult = (void *)result;
34727   return jresult;
34728 }
34729
34730
34731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
34732   int jresult ;
34733   int result;
34734
34735   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
34736   jresult = (int)result;
34737   return jresult;
34738 }
34739
34740
34741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
34742   int jresult ;
34743   int result;
34744
34745   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
34746   jresult = (int)result;
34747   return jresult;
34748 }
34749
34750
34751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
34752   int jresult ;
34753   int result;
34754
34755   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
34756   jresult = (int)result;
34757   return jresult;
34758 }
34759
34760
34761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
34762   int jresult ;
34763   int result;
34764
34765   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
34766   jresult = (int)result;
34767   return jresult;
34768 }
34769
34770
34771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
34772   int jresult ;
34773   int result;
34774
34775   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
34776   jresult = (int)result;
34777   return jresult;
34778 }
34779
34780
34781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
34782   int jresult ;
34783   int result;
34784
34785   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
34786   jresult = (int)result;
34787   return jresult;
34788 }
34789
34790
34791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
34792   int jresult ;
34793   int result;
34794
34795   result = (int)Dali::PanGestureDetector::Property::PANNING;
34796   jresult = (int)result;
34797   return jresult;
34798 }
34799
34800
34801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
34802   void * jresult ;
34803   Dali::PanGestureDetector::Property *result = 0 ;
34804
34805   {
34806     try {
34807       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
34808     } catch (std::out_of_range& e) {
34809       {
34810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34811       };
34812     } catch (std::exception& e) {
34813       {
34814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34815       };
34816     } catch (...) {
34817       {
34818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34819       };
34820     }
34821   }
34822   jresult = (void *)result;
34823   return jresult;
34824 }
34825
34826
34827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
34828   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
34829
34830   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
34831   {
34832     try {
34833       delete arg1;
34834     } catch (std::out_of_range& e) {
34835       {
34836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34837       };
34838     } catch (std::exception& e) {
34839       {
34840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34841       };
34842     } catch (...) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34845       };
34846     }
34847   }
34848 }
34849
34850
34851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
34852   void * jresult ;
34853   Dali::Radian *result = 0 ;
34854
34855   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
34856   jresult = (void *)result;
34857   return jresult;
34858 }
34859
34860
34861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
34862   void * jresult ;
34863   Dali::Radian *result = 0 ;
34864
34865   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
34866   jresult = (void *)result;
34867   return jresult;
34868 }
34869
34870
34871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
34872   void * jresult ;
34873   Dali::Radian *result = 0 ;
34874
34875   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
34876   jresult = (void *)result;
34877   return jresult;
34878 }
34879
34880
34881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
34882   void * jresult ;
34883   Dali::Radian *result = 0 ;
34884
34885   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
34886   jresult = (void *)result;
34887   return jresult;
34888 }
34889
34890
34891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
34892   void * jresult ;
34893   Dali::Radian *result = 0 ;
34894
34895   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
34896   jresult = (void *)result;
34897   return jresult;
34898 }
34899
34900
34901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
34902   void * jresult ;
34903   Dali::Radian *result = 0 ;
34904
34905   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
34906   jresult = (void *)result;
34907   return jresult;
34908 }
34909
34910
34911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
34912   void * jresult ;
34913   Dali::Radian *result = 0 ;
34914
34915   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
34916   jresult = (void *)result;
34917   return jresult;
34918 }
34919
34920
34921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
34922   void * jresult ;
34923   Dali::PanGestureDetector *result = 0 ;
34924
34925   {
34926     try {
34927       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
34928     } catch (std::out_of_range& e) {
34929       {
34930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34931       };
34932     } catch (std::exception& e) {
34933       {
34934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34935       };
34936     } catch (...) {
34937       {
34938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34939       };
34940     }
34941   }
34942   jresult = (void *)result;
34943   return jresult;
34944 }
34945
34946
34947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
34948   void * jresult ;
34949   Dali::PanGestureDetector result;
34950
34951   {
34952     try {
34953       result = Dali::PanGestureDetector::New();
34954     } catch (std::out_of_range& e) {
34955       {
34956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34957       };
34958     } catch (std::exception& e) {
34959       {
34960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34961       };
34962     } catch (...) {
34963       {
34964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34965       };
34966     }
34967   }
34968   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
34969   return jresult;
34970 }
34971
34972
34973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
34974   void * jresult ;
34975   Dali::BaseHandle arg1 ;
34976   Dali::BaseHandle *argp1 ;
34977   Dali::PanGestureDetector result;
34978
34979   argp1 = (Dali::BaseHandle *)jarg1;
34980   if (!argp1) {
34981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34982     return 0;
34983   }
34984   arg1 = *argp1;
34985   {
34986     try {
34987       result = Dali::PanGestureDetector::DownCast(arg1);
34988     } catch (std::out_of_range& e) {
34989       {
34990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34991       };
34992     } catch (std::exception& e) {
34993       {
34994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34995       };
34996     } catch (...) {
34997       {
34998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34999       };
35000     }
35001   }
35002   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35003   return jresult;
35004 }
35005
35006
35007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35008   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35009
35010   arg1 = (Dali::PanGestureDetector *)jarg1;
35011   {
35012     try {
35013       delete arg1;
35014     } catch (std::out_of_range& e) {
35015       {
35016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35017       };
35018     } catch (std::exception& e) {
35019       {
35020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35021       };
35022     } catch (...) {
35023       {
35024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35025       };
35026     }
35027   }
35028 }
35029
35030
35031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35032   void * jresult ;
35033   Dali::PanGestureDetector *arg1 = 0 ;
35034   Dali::PanGestureDetector *result = 0 ;
35035
35036   arg1 = (Dali::PanGestureDetector *)jarg1;
35037   if (!arg1) {
35038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35039     return 0;
35040   }
35041   {
35042     try {
35043       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35044     } catch (std::out_of_range& e) {
35045       {
35046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35047       };
35048     } catch (std::exception& e) {
35049       {
35050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35051       };
35052     } catch (...) {
35053       {
35054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35055       };
35056     }
35057   }
35058   jresult = (void *)result;
35059   return jresult;
35060 }
35061
35062
35063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35064   void * jresult ;
35065   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35066   Dali::PanGestureDetector *arg2 = 0 ;
35067   Dali::PanGestureDetector *result = 0 ;
35068
35069   arg1 = (Dali::PanGestureDetector *)jarg1;
35070   arg2 = (Dali::PanGestureDetector *)jarg2;
35071   if (!arg2) {
35072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35073     return 0;
35074   }
35075   {
35076     try {
35077       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35078     } catch (std::out_of_range& e) {
35079       {
35080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35081       };
35082     } catch (std::exception& e) {
35083       {
35084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35085       };
35086     } catch (...) {
35087       {
35088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35089       };
35090     }
35091   }
35092   jresult = (void *)result;
35093   return jresult;
35094 }
35095
35096
35097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35098   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35099   unsigned int arg2 ;
35100
35101   arg1 = (Dali::PanGestureDetector *)jarg1;
35102   arg2 = (unsigned int)jarg2;
35103   {
35104     try {
35105       (arg1)->SetMinimumTouchesRequired(arg2);
35106     } catch (std::out_of_range& e) {
35107       {
35108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35109       };
35110     } catch (std::exception& e) {
35111       {
35112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35113       };
35114     } catch (...) {
35115       {
35116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35117       };
35118     }
35119   }
35120 }
35121
35122
35123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35124   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35125   unsigned int arg2 ;
35126
35127   arg1 = (Dali::PanGestureDetector *)jarg1;
35128   arg2 = (unsigned int)jarg2;
35129   {
35130     try {
35131       (arg1)->SetMaximumTouchesRequired(arg2);
35132     } catch (std::out_of_range& e) {
35133       {
35134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35135       };
35136     } catch (std::exception& e) {
35137       {
35138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35139       };
35140     } catch (...) {
35141       {
35142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35143       };
35144     }
35145   }
35146 }
35147
35148
35149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35150   unsigned int jresult ;
35151   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35152   unsigned int result;
35153
35154   arg1 = (Dali::PanGestureDetector *)jarg1;
35155   {
35156     try {
35157       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35158     } catch (std::out_of_range& e) {
35159       {
35160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35161       };
35162     } catch (std::exception& e) {
35163       {
35164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35165       };
35166     } catch (...) {
35167       {
35168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35169       };
35170     }
35171   }
35172   jresult = result;
35173   return jresult;
35174 }
35175
35176
35177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35178   unsigned int jresult ;
35179   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35180   unsigned int result;
35181
35182   arg1 = (Dali::PanGestureDetector *)jarg1;
35183   {
35184     try {
35185       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35186     } catch (std::out_of_range& e) {
35187       {
35188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35189       };
35190     } catch (std::exception& e) {
35191       {
35192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35193       };
35194     } catch (...) {
35195       {
35196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35197       };
35198     }
35199   }
35200   jresult = result;
35201   return jresult;
35202 }
35203
35204
35205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35206   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35207   Dali::Radian arg2 ;
35208   Dali::Radian arg3 ;
35209   Dali::Radian *argp2 ;
35210   Dali::Radian *argp3 ;
35211
35212   arg1 = (Dali::PanGestureDetector *)jarg1;
35213   argp2 = (Dali::Radian *)jarg2;
35214   if (!argp2) {
35215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35216     return ;
35217   }
35218   arg2 = *argp2;
35219   argp3 = (Dali::Radian *)jarg3;
35220   if (!argp3) {
35221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35222     return ;
35223   }
35224   arg3 = *argp3;
35225   {
35226     try {
35227       (arg1)->AddAngle(arg2,arg3);
35228     } catch (std::out_of_range& e) {
35229       {
35230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35231       };
35232     } catch (std::exception& e) {
35233       {
35234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35235       };
35236     } catch (...) {
35237       {
35238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35239       };
35240     }
35241   }
35242 }
35243
35244
35245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35246   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35247   Dali::Radian arg2 ;
35248   Dali::Radian *argp2 ;
35249
35250   arg1 = (Dali::PanGestureDetector *)jarg1;
35251   argp2 = (Dali::Radian *)jarg2;
35252   if (!argp2) {
35253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35254     return ;
35255   }
35256   arg2 = *argp2;
35257   {
35258     try {
35259       (arg1)->AddAngle(arg2);
35260     } catch (std::out_of_range& e) {
35261       {
35262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35263       };
35264     } catch (std::exception& e) {
35265       {
35266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35267       };
35268     } catch (...) {
35269       {
35270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35271       };
35272     }
35273   }
35274 }
35275
35276
35277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35278   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35279   Dali::Radian arg2 ;
35280   Dali::Radian arg3 ;
35281   Dali::Radian *argp2 ;
35282   Dali::Radian *argp3 ;
35283
35284   arg1 = (Dali::PanGestureDetector *)jarg1;
35285   argp2 = (Dali::Radian *)jarg2;
35286   if (!argp2) {
35287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35288     return ;
35289   }
35290   arg2 = *argp2;
35291   argp3 = (Dali::Radian *)jarg3;
35292   if (!argp3) {
35293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35294     return ;
35295   }
35296   arg3 = *argp3;
35297   {
35298     try {
35299       (arg1)->AddDirection(arg2,arg3);
35300     } catch (std::out_of_range& e) {
35301       {
35302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35303       };
35304     } catch (std::exception& e) {
35305       {
35306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35307       };
35308     } catch (...) {
35309       {
35310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35311       };
35312     }
35313   }
35314 }
35315
35316
35317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35318   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35319   Dali::Radian arg2 ;
35320   Dali::Radian *argp2 ;
35321
35322   arg1 = (Dali::PanGestureDetector *)jarg1;
35323   argp2 = (Dali::Radian *)jarg2;
35324   if (!argp2) {
35325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35326     return ;
35327   }
35328   arg2 = *argp2;
35329   {
35330     try {
35331       (arg1)->AddDirection(arg2);
35332     } catch (std::out_of_range& e) {
35333       {
35334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35335       };
35336     } catch (std::exception& e) {
35337       {
35338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35339       };
35340     } catch (...) {
35341       {
35342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35343       };
35344     }
35345   }
35346 }
35347
35348
35349 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35350   unsigned long jresult ;
35351   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35352   size_t result;
35353
35354   arg1 = (Dali::PanGestureDetector *)jarg1;
35355   {
35356     try {
35357       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35358     } catch (std::out_of_range& e) {
35359       {
35360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35361       };
35362     } catch (std::exception& e) {
35363       {
35364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35365       };
35366     } catch (...) {
35367       {
35368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35369       };
35370     }
35371   }
35372   jresult = (unsigned long)result;
35373   return jresult;
35374 }
35375
35376
35377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35378   void * jresult ;
35379   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35380   size_t arg2 ;
35381   Dali::PanGestureDetector::AngleThresholdPair result;
35382
35383   arg1 = (Dali::PanGestureDetector *)jarg1;
35384   arg2 = (size_t)jarg2;
35385   {
35386     try {
35387       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35388     } catch (std::out_of_range& e) {
35389       {
35390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35391       };
35392     } catch (std::exception& e) {
35393       {
35394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35395       };
35396     } catch (...) {
35397       {
35398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35399       };
35400     }
35401   }
35402   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35403   return jresult;
35404 }
35405
35406
35407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35408   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35409
35410   arg1 = (Dali::PanGestureDetector *)jarg1;
35411   {
35412     try {
35413       (arg1)->ClearAngles();
35414     } catch (std::out_of_range& e) {
35415       {
35416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35417       };
35418     } catch (std::exception& e) {
35419       {
35420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35421       };
35422     } catch (...) {
35423       {
35424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35425       };
35426     }
35427   }
35428 }
35429
35430
35431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35432   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35433   Dali::Radian arg2 ;
35434   Dali::Radian *argp2 ;
35435
35436   arg1 = (Dali::PanGestureDetector *)jarg1;
35437   argp2 = (Dali::Radian *)jarg2;
35438   if (!argp2) {
35439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35440     return ;
35441   }
35442   arg2 = *argp2;
35443   {
35444     try {
35445       (arg1)->RemoveAngle(arg2);
35446     } catch (std::out_of_range& e) {
35447       {
35448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35449       };
35450     } catch (std::exception& e) {
35451       {
35452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35453       };
35454     } catch (...) {
35455       {
35456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35457       };
35458     }
35459   }
35460 }
35461
35462
35463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35464   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35465   Dali::Radian arg2 ;
35466   Dali::Radian *argp2 ;
35467
35468   arg1 = (Dali::PanGestureDetector *)jarg1;
35469   argp2 = (Dali::Radian *)jarg2;
35470   if (!argp2) {
35471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35472     return ;
35473   }
35474   arg2 = *argp2;
35475   {
35476     try {
35477       (arg1)->RemoveDirection(arg2);
35478     } catch (std::out_of_range& e) {
35479       {
35480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35481       };
35482     } catch (std::exception& e) {
35483       {
35484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35485       };
35486     } catch (...) {
35487       {
35488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35489       };
35490     }
35491   }
35492 }
35493
35494
35495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35496   void * jresult ;
35497   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35498   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35499
35500   arg1 = (Dali::PanGestureDetector *)jarg1;
35501   {
35502     try {
35503       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35504     } catch (std::out_of_range& e) {
35505       {
35506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35507       };
35508     } catch (std::exception& e) {
35509       {
35510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35511       };
35512     } catch (...) {
35513       {
35514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35515       };
35516     }
35517   }
35518   jresult = (void *)result;
35519   return jresult;
35520 }
35521
35522
35523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35524   Dali::PanGesture *arg1 = 0 ;
35525
35526   arg1 = (Dali::PanGesture *)jarg1;
35527   if (!arg1) {
35528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35529     return ;
35530   }
35531   {
35532     try {
35533       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35534     } catch (std::out_of_range& e) {
35535       {
35536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35537       };
35538     } catch (std::exception& e) {
35539       {
35540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35541       };
35542     } catch (...) {
35543       {
35544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35545       };
35546     }
35547   }
35548 }
35549
35550
35551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35552   void * jresult ;
35553   Dali::PanGesture *result = 0 ;
35554
35555   {
35556     try {
35557       result = (Dali::PanGesture *)new Dali::PanGesture();
35558     } catch (std::out_of_range& e) {
35559       {
35560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35561       };
35562     } catch (std::exception& e) {
35563       {
35564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35565       };
35566     } catch (...) {
35567       {
35568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35569       };
35570     }
35571   }
35572   jresult = (void *)result;
35573   return jresult;
35574 }
35575
35576
35577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35578   void * jresult ;
35579   Dali::Gesture::State arg1 ;
35580   Dali::PanGesture *result = 0 ;
35581
35582   arg1 = (Dali::Gesture::State)jarg1;
35583   {
35584     try {
35585       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35586     } catch (std::out_of_range& e) {
35587       {
35588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35589       };
35590     } catch (std::exception& e) {
35591       {
35592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35593       };
35594     } catch (...) {
35595       {
35596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35597       };
35598     }
35599   }
35600   jresult = (void *)result;
35601   return jresult;
35602 }
35603
35604
35605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
35606   void * jresult ;
35607   Dali::PanGesture *arg1 = 0 ;
35608   Dali::PanGesture *result = 0 ;
35609
35610   arg1 = (Dali::PanGesture *)jarg1;
35611   if (!arg1) {
35612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35613     return 0;
35614   }
35615   {
35616     try {
35617       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
35618     } catch (std::out_of_range& e) {
35619       {
35620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35621       };
35622     } catch (std::exception& e) {
35623       {
35624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35625       };
35626     } catch (...) {
35627       {
35628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35629       };
35630     }
35631   }
35632   jresult = (void *)result;
35633   return jresult;
35634 }
35635
35636
35637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
35638   void * jresult ;
35639   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35640   Dali::PanGesture *arg2 = 0 ;
35641   Dali::PanGesture *result = 0 ;
35642
35643   arg1 = (Dali::PanGesture *)jarg1;
35644   arg2 = (Dali::PanGesture *)jarg2;
35645   if (!arg2) {
35646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35647     return 0;
35648   }
35649   {
35650     try {
35651       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
35652     } catch (std::out_of_range& e) {
35653       {
35654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35655       };
35656     } catch (std::exception& e) {
35657       {
35658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35659       };
35660     } catch (...) {
35661       {
35662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35663       };
35664     }
35665   }
35666   jresult = (void *)result;
35667   return jresult;
35668 }
35669
35670
35671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
35672   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35673
35674   arg1 = (Dali::PanGesture *)jarg1;
35675   {
35676     try {
35677       delete arg1;
35678     } catch (std::out_of_range& e) {
35679       {
35680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35681       };
35682     } catch (std::exception& e) {
35683       {
35684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35685       };
35686     } catch (...) {
35687       {
35688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35689       };
35690     }
35691   }
35692 }
35693
35694
35695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
35696   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35697   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35698
35699   arg1 = (Dali::PanGesture *)jarg1;
35700   arg2 = (Dali::Vector2 *)jarg2;
35701   if (arg1) (arg1)->velocity = *arg2;
35702 }
35703
35704
35705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
35706   void * jresult ;
35707   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35708   Dali::Vector2 *result = 0 ;
35709
35710   arg1 = (Dali::PanGesture *)jarg1;
35711   result = (Dali::Vector2 *)& ((arg1)->velocity);
35712   jresult = (void *)result;
35713   return jresult;
35714 }
35715
35716
35717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
35718   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35719   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35720
35721   arg1 = (Dali::PanGesture *)jarg1;
35722   arg2 = (Dali::Vector2 *)jarg2;
35723   if (arg1) (arg1)->displacement = *arg2;
35724 }
35725
35726
35727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
35728   void * jresult ;
35729   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35730   Dali::Vector2 *result = 0 ;
35731
35732   arg1 = (Dali::PanGesture *)jarg1;
35733   result = (Dali::Vector2 *)& ((arg1)->displacement);
35734   jresult = (void *)result;
35735   return jresult;
35736 }
35737
35738
35739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
35740   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35741   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35742
35743   arg1 = (Dali::PanGesture *)jarg1;
35744   arg2 = (Dali::Vector2 *)jarg2;
35745   if (arg1) (arg1)->position = *arg2;
35746 }
35747
35748
35749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
35750   void * jresult ;
35751   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35752   Dali::Vector2 *result = 0 ;
35753
35754   arg1 = (Dali::PanGesture *)jarg1;
35755   result = (Dali::Vector2 *)& ((arg1)->position);
35756   jresult = (void *)result;
35757   return jresult;
35758 }
35759
35760
35761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
35762   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35763   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35764
35765   arg1 = (Dali::PanGesture *)jarg1;
35766   arg2 = (Dali::Vector2 *)jarg2;
35767   if (arg1) (arg1)->screenVelocity = *arg2;
35768 }
35769
35770
35771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
35772   void * jresult ;
35773   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35774   Dali::Vector2 *result = 0 ;
35775
35776   arg1 = (Dali::PanGesture *)jarg1;
35777   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
35778   jresult = (void *)result;
35779   return jresult;
35780 }
35781
35782
35783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
35784   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35785   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35786
35787   arg1 = (Dali::PanGesture *)jarg1;
35788   arg2 = (Dali::Vector2 *)jarg2;
35789   if (arg1) (arg1)->screenDisplacement = *arg2;
35790 }
35791
35792
35793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
35794   void * jresult ;
35795   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35796   Dali::Vector2 *result = 0 ;
35797
35798   arg1 = (Dali::PanGesture *)jarg1;
35799   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
35800   jresult = (void *)result;
35801   return jresult;
35802 }
35803
35804
35805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
35806   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35807   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35808
35809   arg1 = (Dali::PanGesture *)jarg1;
35810   arg2 = (Dali::Vector2 *)jarg2;
35811   if (arg1) (arg1)->screenPosition = *arg2;
35812 }
35813
35814
35815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
35816   void * jresult ;
35817   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35818   Dali::Vector2 *result = 0 ;
35819
35820   arg1 = (Dali::PanGesture *)jarg1;
35821   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
35822   jresult = (void *)result;
35823   return jresult;
35824 }
35825
35826
35827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
35828   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35829   unsigned int arg2 ;
35830
35831   arg1 = (Dali::PanGesture *)jarg1;
35832   arg2 = (unsigned int)jarg2;
35833   if (arg1) (arg1)->numberOfTouches = arg2;
35834 }
35835
35836
35837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
35838   unsigned int jresult ;
35839   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35840   unsigned int result;
35841
35842   arg1 = (Dali::PanGesture *)jarg1;
35843   result = (unsigned int) ((arg1)->numberOfTouches);
35844   jresult = result;
35845   return jresult;
35846 }
35847
35848
35849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
35850   float jresult ;
35851   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35852   float result;
35853
35854   arg1 = (Dali::PanGesture *)jarg1;
35855   {
35856     try {
35857       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
35858     } catch (std::out_of_range& e) {
35859       {
35860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35861       };
35862     } catch (std::exception& e) {
35863       {
35864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35865       };
35866     } catch (...) {
35867       {
35868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35869       };
35870     }
35871   }
35872   jresult = result;
35873   return jresult;
35874 }
35875
35876
35877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
35878   float jresult ;
35879   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35880   float result;
35881
35882   arg1 = (Dali::PanGesture *)jarg1;
35883   {
35884     try {
35885       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
35886     } catch (std::out_of_range& e) {
35887       {
35888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35889       };
35890     } catch (std::exception& e) {
35891       {
35892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35893       };
35894     } catch (...) {
35895       {
35896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35897       };
35898     }
35899   }
35900   jresult = result;
35901   return jresult;
35902 }
35903
35904
35905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
35906   float jresult ;
35907   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35908   float result;
35909
35910   arg1 = (Dali::PanGesture *)jarg1;
35911   {
35912     try {
35913       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
35914     } catch (std::out_of_range& e) {
35915       {
35916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35917       };
35918     } catch (std::exception& e) {
35919       {
35920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35921       };
35922     } catch (...) {
35923       {
35924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35925       };
35926     }
35927   }
35928   jresult = result;
35929   return jresult;
35930 }
35931
35932
35933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
35934   float jresult ;
35935   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35936   float result;
35937
35938   arg1 = (Dali::PanGesture *)jarg1;
35939   {
35940     try {
35941       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
35942     } catch (std::out_of_range& e) {
35943       {
35944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35945       };
35946     } catch (std::exception& e) {
35947       {
35948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35949       };
35950     } catch (...) {
35951       {
35952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35953       };
35954     }
35955   }
35956   jresult = result;
35957   return jresult;
35958 }
35959
35960
35961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
35962   void * jresult ;
35963   Dali::PinchGestureDetector *result = 0 ;
35964
35965   {
35966     try {
35967       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
35968     } catch (std::out_of_range& e) {
35969       {
35970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35971       };
35972     } catch (std::exception& e) {
35973       {
35974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35975       };
35976     } catch (...) {
35977       {
35978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35979       };
35980     }
35981   }
35982   jresult = (void *)result;
35983   return jresult;
35984 }
35985
35986
35987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
35988   void * jresult ;
35989   Dali::PinchGestureDetector result;
35990
35991   {
35992     try {
35993       result = Dali::PinchGestureDetector::New();
35994     } catch (std::out_of_range& e) {
35995       {
35996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35997       };
35998     } catch (std::exception& e) {
35999       {
36000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36001       };
36002     } catch (...) {
36003       {
36004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36005       };
36006     }
36007   }
36008   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36009   return jresult;
36010 }
36011
36012
36013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36014   void * jresult ;
36015   Dali::BaseHandle arg1 ;
36016   Dali::BaseHandle *argp1 ;
36017   Dali::PinchGestureDetector result;
36018
36019   argp1 = (Dali::BaseHandle *)jarg1;
36020   if (!argp1) {
36021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36022     return 0;
36023   }
36024   arg1 = *argp1;
36025   {
36026     try {
36027       result = Dali::PinchGestureDetector::DownCast(arg1);
36028     } catch (std::out_of_range& e) {
36029       {
36030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36031       };
36032     } catch (std::exception& e) {
36033       {
36034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36035       };
36036     } catch (...) {
36037       {
36038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36039       };
36040     }
36041   }
36042   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36043   return jresult;
36044 }
36045
36046
36047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36048   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36049
36050   arg1 = (Dali::PinchGestureDetector *)jarg1;
36051   {
36052     try {
36053       delete arg1;
36054     } catch (std::out_of_range& e) {
36055       {
36056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36057       };
36058     } catch (std::exception& e) {
36059       {
36060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36061       };
36062     } catch (...) {
36063       {
36064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36065       };
36066     }
36067   }
36068 }
36069
36070
36071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36072   void * jresult ;
36073   Dali::PinchGestureDetector *arg1 = 0 ;
36074   Dali::PinchGestureDetector *result = 0 ;
36075
36076   arg1 = (Dali::PinchGestureDetector *)jarg1;
36077   if (!arg1) {
36078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36079     return 0;
36080   }
36081   {
36082     try {
36083       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36084     } catch (std::out_of_range& e) {
36085       {
36086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36087       };
36088     } catch (std::exception& e) {
36089       {
36090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36091       };
36092     } catch (...) {
36093       {
36094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36095       };
36096     }
36097   }
36098   jresult = (void *)result;
36099   return jresult;
36100 }
36101
36102
36103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36104   void * jresult ;
36105   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36106   Dali::PinchGestureDetector *arg2 = 0 ;
36107   Dali::PinchGestureDetector *result = 0 ;
36108
36109   arg1 = (Dali::PinchGestureDetector *)jarg1;
36110   arg2 = (Dali::PinchGestureDetector *)jarg2;
36111   if (!arg2) {
36112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36113     return 0;
36114   }
36115   {
36116     try {
36117       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36118     } catch (std::out_of_range& e) {
36119       {
36120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36121       };
36122     } catch (std::exception& e) {
36123       {
36124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36125       };
36126     } catch (...) {
36127       {
36128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36129       };
36130     }
36131   }
36132   jresult = (void *)result;
36133   return jresult;
36134 }
36135
36136
36137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36138   void * jresult ;
36139   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36140   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36141
36142   arg1 = (Dali::PinchGestureDetector *)jarg1;
36143   {
36144     try {
36145       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36146     } catch (std::out_of_range& e) {
36147       {
36148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36149       };
36150     } catch (std::exception& e) {
36151       {
36152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36153       };
36154     } catch (...) {
36155       {
36156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36157       };
36158     }
36159   }
36160   jresult = (void *)result;
36161   return jresult;
36162 }
36163
36164
36165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36166   void * jresult ;
36167   Dali::Gesture::State arg1 ;
36168   Dali::PinchGesture *result = 0 ;
36169
36170   arg1 = (Dali::Gesture::State)jarg1;
36171   {
36172     try {
36173       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36174     } catch (std::out_of_range& e) {
36175       {
36176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36177       };
36178     } catch (std::exception& e) {
36179       {
36180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36181       };
36182     } catch (...) {
36183       {
36184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36185       };
36186     }
36187   }
36188   jresult = (void *)result;
36189   return jresult;
36190 }
36191
36192
36193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36194   void * jresult ;
36195   Dali::PinchGesture *arg1 = 0 ;
36196   Dali::PinchGesture *result = 0 ;
36197
36198   arg1 = (Dali::PinchGesture *)jarg1;
36199   if (!arg1) {
36200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36201     return 0;
36202   }
36203   {
36204     try {
36205       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36206     } catch (std::out_of_range& e) {
36207       {
36208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36209       };
36210     } catch (std::exception& e) {
36211       {
36212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36213       };
36214     } catch (...) {
36215       {
36216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36217       };
36218     }
36219   }
36220   jresult = (void *)result;
36221   return jresult;
36222 }
36223
36224
36225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36226   void * jresult ;
36227   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36228   Dali::PinchGesture *arg2 = 0 ;
36229   Dali::PinchGesture *result = 0 ;
36230
36231   arg1 = (Dali::PinchGesture *)jarg1;
36232   arg2 = (Dali::PinchGesture *)jarg2;
36233   if (!arg2) {
36234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36235     return 0;
36236   }
36237   {
36238     try {
36239       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36240     } catch (std::out_of_range& e) {
36241       {
36242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36243       };
36244     } catch (std::exception& e) {
36245       {
36246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36247       };
36248     } catch (...) {
36249       {
36250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36251       };
36252     }
36253   }
36254   jresult = (void *)result;
36255   return jresult;
36256 }
36257
36258
36259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36260   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36261
36262   arg1 = (Dali::PinchGesture *)jarg1;
36263   {
36264     try {
36265       delete arg1;
36266     } catch (std::out_of_range& e) {
36267       {
36268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36269       };
36270     } catch (std::exception& e) {
36271       {
36272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36273       };
36274     } catch (...) {
36275       {
36276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36277       };
36278     }
36279   }
36280 }
36281
36282
36283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36284   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36285   float arg2 ;
36286
36287   arg1 = (Dali::PinchGesture *)jarg1;
36288   arg2 = (float)jarg2;
36289   if (arg1) (arg1)->scale = arg2;
36290 }
36291
36292
36293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36294   float jresult ;
36295   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36296   float result;
36297
36298   arg1 = (Dali::PinchGesture *)jarg1;
36299   result = (float) ((arg1)->scale);
36300   jresult = result;
36301   return jresult;
36302 }
36303
36304
36305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36306   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36307   float arg2 ;
36308
36309   arg1 = (Dali::PinchGesture *)jarg1;
36310   arg2 = (float)jarg2;
36311   if (arg1) (arg1)->speed = arg2;
36312 }
36313
36314
36315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36316   float jresult ;
36317   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36318   float result;
36319
36320   arg1 = (Dali::PinchGesture *)jarg1;
36321   result = (float) ((arg1)->speed);
36322   jresult = result;
36323   return jresult;
36324 }
36325
36326
36327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36328   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36329   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36330
36331   arg1 = (Dali::PinchGesture *)jarg1;
36332   arg2 = (Dali::Vector2 *)jarg2;
36333   if (arg1) (arg1)->screenCenterPoint = *arg2;
36334 }
36335
36336
36337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36338   void * jresult ;
36339   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36340   Dali::Vector2 *result = 0 ;
36341
36342   arg1 = (Dali::PinchGesture *)jarg1;
36343   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36344   jresult = (void *)result;
36345   return jresult;
36346 }
36347
36348
36349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36350   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36351   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36352
36353   arg1 = (Dali::PinchGesture *)jarg1;
36354   arg2 = (Dali::Vector2 *)jarg2;
36355   if (arg1) (arg1)->localCenterPoint = *arg2;
36356 }
36357
36358
36359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36360   void * jresult ;
36361   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36362   Dali::Vector2 *result = 0 ;
36363
36364   arg1 = (Dali::PinchGesture *)jarg1;
36365   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36366   jresult = (void *)result;
36367   return jresult;
36368 }
36369
36370
36371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36372   void * jresult ;
36373   Dali::TapGestureDetector *result = 0 ;
36374
36375   {
36376     try {
36377       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36378     } catch (std::out_of_range& e) {
36379       {
36380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36381       };
36382     } catch (std::exception& e) {
36383       {
36384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36385       };
36386     } catch (...) {
36387       {
36388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36389       };
36390     }
36391   }
36392   jresult = (void *)result;
36393   return jresult;
36394 }
36395
36396
36397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36398   void * jresult ;
36399   Dali::TapGestureDetector result;
36400
36401   {
36402     try {
36403       result = Dali::TapGestureDetector::New();
36404     } catch (std::out_of_range& e) {
36405       {
36406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36407       };
36408     } catch (std::exception& e) {
36409       {
36410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36411       };
36412     } catch (...) {
36413       {
36414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36415       };
36416     }
36417   }
36418   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36419   return jresult;
36420 }
36421
36422
36423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36424   void * jresult ;
36425   unsigned int arg1 ;
36426   Dali::TapGestureDetector result;
36427
36428   arg1 = (unsigned int)jarg1;
36429   {
36430     try {
36431       result = Dali::TapGestureDetector::New(arg1);
36432     } catch (std::out_of_range& e) {
36433       {
36434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36435       };
36436     } catch (std::exception& e) {
36437       {
36438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36439       };
36440     } catch (...) {
36441       {
36442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36443       };
36444     }
36445   }
36446   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36447   return jresult;
36448 }
36449
36450
36451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36452   void * jresult ;
36453   Dali::BaseHandle arg1 ;
36454   Dali::BaseHandle *argp1 ;
36455   Dali::TapGestureDetector result;
36456
36457   argp1 = (Dali::BaseHandle *)jarg1;
36458   if (!argp1) {
36459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36460     return 0;
36461   }
36462   arg1 = *argp1;
36463   {
36464     try {
36465       result = Dali::TapGestureDetector::DownCast(arg1);
36466     } catch (std::out_of_range& e) {
36467       {
36468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36469       };
36470     } catch (std::exception& e) {
36471       {
36472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36473       };
36474     } catch (...) {
36475       {
36476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36477       };
36478     }
36479   }
36480   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36481   return jresult;
36482 }
36483
36484
36485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36486   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36487
36488   arg1 = (Dali::TapGestureDetector *)jarg1;
36489   {
36490     try {
36491       delete arg1;
36492     } catch (std::out_of_range& e) {
36493       {
36494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36495       };
36496     } catch (std::exception& e) {
36497       {
36498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36499       };
36500     } catch (...) {
36501       {
36502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36503       };
36504     }
36505   }
36506 }
36507
36508
36509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36510   void * jresult ;
36511   Dali::TapGestureDetector *arg1 = 0 ;
36512   Dali::TapGestureDetector *result = 0 ;
36513
36514   arg1 = (Dali::TapGestureDetector *)jarg1;
36515   if (!arg1) {
36516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36517     return 0;
36518   }
36519   {
36520     try {
36521       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36522     } catch (std::out_of_range& e) {
36523       {
36524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36525       };
36526     } catch (std::exception& e) {
36527       {
36528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36529       };
36530     } catch (...) {
36531       {
36532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36533       };
36534     }
36535   }
36536   jresult = (void *)result;
36537   return jresult;
36538 }
36539
36540
36541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36542   void * jresult ;
36543   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36544   Dali::TapGestureDetector *arg2 = 0 ;
36545   Dali::TapGestureDetector *result = 0 ;
36546
36547   arg1 = (Dali::TapGestureDetector *)jarg1;
36548   arg2 = (Dali::TapGestureDetector *)jarg2;
36549   if (!arg2) {
36550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36551     return 0;
36552   }
36553   {
36554     try {
36555       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36556     } catch (std::out_of_range& e) {
36557       {
36558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36559       };
36560     } catch (std::exception& e) {
36561       {
36562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36563       };
36564     } catch (...) {
36565       {
36566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36567       };
36568     }
36569   }
36570   jresult = (void *)result;
36571   return jresult;
36572 }
36573
36574
36575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36576   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36577   unsigned int arg2 ;
36578
36579   arg1 = (Dali::TapGestureDetector *)jarg1;
36580   arg2 = (unsigned int)jarg2;
36581   {
36582     try {
36583       (arg1)->SetMinimumTapsRequired(arg2);
36584     } catch (std::out_of_range& e) {
36585       {
36586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36587       };
36588     } catch (std::exception& e) {
36589       {
36590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36591       };
36592     } catch (...) {
36593       {
36594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36595       };
36596     }
36597   }
36598 }
36599
36600
36601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36602   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36603   unsigned int arg2 ;
36604
36605   arg1 = (Dali::TapGestureDetector *)jarg1;
36606   arg2 = (unsigned int)jarg2;
36607   {
36608     try {
36609       (arg1)->SetMaximumTapsRequired(arg2);
36610     } catch (std::out_of_range& e) {
36611       {
36612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36613       };
36614     } catch (std::exception& e) {
36615       {
36616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36617       };
36618     } catch (...) {
36619       {
36620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36621       };
36622     }
36623   }
36624 }
36625
36626
36627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
36628   unsigned int jresult ;
36629   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36630   unsigned int result;
36631
36632   arg1 = (Dali::TapGestureDetector *)jarg1;
36633   {
36634     try {
36635       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
36636     } catch (std::out_of_range& e) {
36637       {
36638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36639       };
36640     } catch (std::exception& e) {
36641       {
36642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36643       };
36644     } catch (...) {
36645       {
36646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36647       };
36648     }
36649   }
36650   jresult = result;
36651   return jresult;
36652 }
36653
36654
36655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
36656   unsigned int jresult ;
36657   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36658   unsigned int result;
36659
36660   arg1 = (Dali::TapGestureDetector *)jarg1;
36661   {
36662     try {
36663       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
36664     } catch (std::out_of_range& e) {
36665       {
36666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36667       };
36668     } catch (std::exception& e) {
36669       {
36670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36671       };
36672     } catch (...) {
36673       {
36674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36675       };
36676     }
36677   }
36678   jresult = result;
36679   return jresult;
36680 }
36681
36682
36683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
36684   void * jresult ;
36685   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36686   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
36687
36688   arg1 = (Dali::TapGestureDetector *)jarg1;
36689   {
36690     try {
36691       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36692     } catch (std::out_of_range& e) {
36693       {
36694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36695       };
36696     } catch (std::exception& e) {
36697       {
36698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36699       };
36700     } catch (...) {
36701       {
36702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36703       };
36704     }
36705   }
36706   jresult = (void *)result;
36707   return jresult;
36708 }
36709
36710
36711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
36712   void * jresult ;
36713   Dali::TapGesture *result = 0 ;
36714
36715   {
36716     try {
36717       result = (Dali::TapGesture *)new Dali::TapGesture();
36718     } catch (std::out_of_range& e) {
36719       {
36720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36721       };
36722     } catch (std::exception& e) {
36723       {
36724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36725       };
36726     } catch (...) {
36727       {
36728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36729       };
36730     }
36731   }
36732   jresult = (void *)result;
36733   return jresult;
36734 }
36735
36736
36737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
36738   void * jresult ;
36739   Dali::TapGesture *arg1 = 0 ;
36740   Dali::TapGesture *result = 0 ;
36741
36742   arg1 = (Dali::TapGesture *)jarg1;
36743   if (!arg1) {
36744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
36745     return 0;
36746   }
36747   {
36748     try {
36749       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
36750     } catch (std::out_of_range& e) {
36751       {
36752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36753       };
36754     } catch (std::exception& e) {
36755       {
36756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36757       };
36758     } catch (...) {
36759       {
36760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36761       };
36762     }
36763   }
36764   jresult = (void *)result;
36765   return jresult;
36766 }
36767
36768
36769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
36770   void * jresult ;
36771   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36772   Dali::TapGesture *arg2 = 0 ;
36773   Dali::TapGesture *result = 0 ;
36774
36775   arg1 = (Dali::TapGesture *)jarg1;
36776   arg2 = (Dali::TapGesture *)jarg2;
36777   if (!arg2) {
36778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
36779     return 0;
36780   }
36781   {
36782     try {
36783       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
36784     } catch (std::out_of_range& e) {
36785       {
36786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36787       };
36788     } catch (std::exception& e) {
36789       {
36790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36791       };
36792     } catch (...) {
36793       {
36794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36795       };
36796     }
36797   }
36798   jresult = (void *)result;
36799   return jresult;
36800 }
36801
36802
36803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
36804   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36805
36806   arg1 = (Dali::TapGesture *)jarg1;
36807   {
36808     try {
36809       delete arg1;
36810     } catch (std::out_of_range& e) {
36811       {
36812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36813       };
36814     } catch (std::exception& e) {
36815       {
36816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36817       };
36818     } catch (...) {
36819       {
36820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36821       };
36822     }
36823   }
36824 }
36825
36826
36827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
36828   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36829   unsigned int arg2 ;
36830
36831   arg1 = (Dali::TapGesture *)jarg1;
36832   arg2 = (unsigned int)jarg2;
36833   if (arg1) (arg1)->numberOfTaps = arg2;
36834 }
36835
36836
36837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
36838   unsigned int jresult ;
36839   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36840   unsigned int result;
36841
36842   arg1 = (Dali::TapGesture *)jarg1;
36843   result = (unsigned int) ((arg1)->numberOfTaps);
36844   jresult = result;
36845   return jresult;
36846 }
36847
36848
36849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36850   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36851   unsigned int arg2 ;
36852
36853   arg1 = (Dali::TapGesture *)jarg1;
36854   arg2 = (unsigned int)jarg2;
36855   if (arg1) (arg1)->numberOfTouches = arg2;
36856 }
36857
36858
36859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
36860   unsigned int jresult ;
36861   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36862   unsigned int result;
36863
36864   arg1 = (Dali::TapGesture *)jarg1;
36865   result = (unsigned int) ((arg1)->numberOfTouches);
36866   jresult = result;
36867   return jresult;
36868 }
36869
36870
36871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
36872   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36873   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36874
36875   arg1 = (Dali::TapGesture *)jarg1;
36876   arg2 = (Dali::Vector2 *)jarg2;
36877   if (arg1) (arg1)->screenPoint = *arg2;
36878 }
36879
36880
36881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
36882   void * jresult ;
36883   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36884   Dali::Vector2 *result = 0 ;
36885
36886   arg1 = (Dali::TapGesture *)jarg1;
36887   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
36888   jresult = (void *)result;
36889   return jresult;
36890 }
36891
36892
36893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
36894   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36895   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36896
36897   arg1 = (Dali::TapGesture *)jarg1;
36898   arg2 = (Dali::Vector2 *)jarg2;
36899   if (arg1) (arg1)->localPoint = *arg2;
36900 }
36901
36902
36903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
36904   void * jresult ;
36905   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36906   Dali::Vector2 *result = 0 ;
36907
36908   arg1 = (Dali::TapGesture *)jarg1;
36909   result = (Dali::Vector2 *)& ((arg1)->localPoint);
36910   jresult = (void *)result;
36911   return jresult;
36912 }
36913
36914
36915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
36916   void * jresult ;
36917   Dali::AlphaFunction *result = 0 ;
36918
36919   {
36920     try {
36921       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
36922     } catch (std::out_of_range& e) {
36923       {
36924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36925       };
36926     } catch (std::exception& e) {
36927       {
36928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36929       };
36930     } catch (...) {
36931       {
36932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36933       };
36934     }
36935   }
36936   jresult = (void *)result;
36937   return jresult;
36938 }
36939
36940
36941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
36942   void * jresult ;
36943   Dali::AlphaFunction::BuiltinFunction arg1 ;
36944   Dali::AlphaFunction *result = 0 ;
36945
36946   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
36947   {
36948     try {
36949       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
36950     } catch (std::out_of_range& e) {
36951       {
36952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36953       };
36954     } catch (std::exception& e) {
36955       {
36956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36957       };
36958     } catch (...) {
36959       {
36960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36961       };
36962     }
36963   }
36964   jresult = (void *)result;
36965   return jresult;
36966 }
36967
36968
36969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
36970   void * jresult ;
36971   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
36972   Dali::AlphaFunction *result = 0 ;
36973
36974   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
36975   {
36976     try {
36977       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
36978     } catch (std::out_of_range& e) {
36979       {
36980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36981       };
36982     } catch (std::exception& e) {
36983       {
36984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36985       };
36986     } catch (...) {
36987       {
36988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36989       };
36990     }
36991   }
36992   jresult = (void *)result;
36993   return jresult;
36994 }
36995
36996
36997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
36998   void * jresult ;
36999   Dali::Vector2 *arg1 = 0 ;
37000   Dali::Vector2 *arg2 = 0 ;
37001   Dali::AlphaFunction *result = 0 ;
37002
37003   arg1 = (Dali::Vector2 *)jarg1;
37004   if (!arg1) {
37005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37006     return 0;
37007   }
37008   arg2 = (Dali::Vector2 *)jarg2;
37009   if (!arg2) {
37010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37011     return 0;
37012   }
37013   {
37014     try {
37015       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37016     } catch (std::out_of_range& e) {
37017       {
37018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37019       };
37020     } catch (std::exception& e) {
37021       {
37022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37023       };
37024     } catch (...) {
37025       {
37026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37027       };
37028     }
37029   }
37030   jresult = (void *)result;
37031   return jresult;
37032 }
37033
37034
37035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37036   void * jresult ;
37037   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37038   Dali::Vector4 result;
37039
37040   arg1 = (Dali::AlphaFunction *)jarg1;
37041   {
37042     try {
37043       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37044     } catch (std::out_of_range& e) {
37045       {
37046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37047       };
37048     } catch (std::exception& e) {
37049       {
37050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37051       };
37052     } catch (...) {
37053       {
37054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37055       };
37056     }
37057   }
37058   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37059   return jresult;
37060 }
37061
37062
37063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37064   void * jresult ;
37065   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37066   Dali::AlphaFunctionPrototype result;
37067
37068   arg1 = (Dali::AlphaFunction *)jarg1;
37069   {
37070     try {
37071       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37072     } catch (std::out_of_range& e) {
37073       {
37074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (std::exception& e) {
37077       {
37078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37079       };
37080     } catch (...) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37083       };
37084     }
37085   }
37086   jresult = (void *)result;
37087   return jresult;
37088 }
37089
37090
37091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37092   int jresult ;
37093   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37094   Dali::AlphaFunction::BuiltinFunction result;
37095
37096   arg1 = (Dali::AlphaFunction *)jarg1;
37097   {
37098     try {
37099       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37100     } catch (std::out_of_range& e) {
37101       {
37102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37103       };
37104     } catch (std::exception& e) {
37105       {
37106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37107       };
37108     } catch (...) {
37109       {
37110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37111       };
37112     }
37113   }
37114   jresult = (int)result;
37115   return jresult;
37116 }
37117
37118
37119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37120   int jresult ;
37121   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37122   Dali::AlphaFunction::Mode result;
37123
37124   arg1 = (Dali::AlphaFunction *)jarg1;
37125   {
37126     try {
37127       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37128     } catch (std::out_of_range& e) {
37129       {
37130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37131       };
37132     } catch (std::exception& e) {
37133       {
37134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37135       };
37136     } catch (...) {
37137       {
37138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37139       };
37140     }
37141   }
37142   jresult = (int)result;
37143   return jresult;
37144 }
37145
37146
37147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37148   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37149
37150   arg1 = (Dali::AlphaFunction *)jarg1;
37151   {
37152     try {
37153       delete arg1;
37154     } catch (std::out_of_range& e) {
37155       {
37156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37157       };
37158     } catch (std::exception& e) {
37159       {
37160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37161       };
37162     } catch (...) {
37163       {
37164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37165       };
37166     }
37167   }
37168 }
37169
37170
37171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37172   void * jresult ;
37173   Dali::KeyFrames result;
37174
37175   {
37176     try {
37177       result = Dali::KeyFrames::New();
37178     } catch (std::out_of_range& e) {
37179       {
37180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37181       };
37182     } catch (std::exception& e) {
37183       {
37184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37185       };
37186     } catch (...) {
37187       {
37188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37189       };
37190     }
37191   }
37192   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37193   return jresult;
37194 }
37195
37196
37197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37198   void * jresult ;
37199   Dali::BaseHandle arg1 ;
37200   Dali::BaseHandle *argp1 ;
37201   Dali::KeyFrames result;
37202
37203   argp1 = (Dali::BaseHandle *)jarg1;
37204   if (!argp1) {
37205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37206     return 0;
37207   }
37208   arg1 = *argp1;
37209   {
37210     try {
37211       result = Dali::KeyFrames::DownCast(arg1);
37212     } catch (std::out_of_range& e) {
37213       {
37214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37215       };
37216     } catch (std::exception& e) {
37217       {
37218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37219       };
37220     } catch (...) {
37221       {
37222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37223       };
37224     }
37225   }
37226   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37227   return jresult;
37228 }
37229
37230
37231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37232   void * jresult ;
37233   Dali::KeyFrames *result = 0 ;
37234
37235   {
37236     try {
37237       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37238     } catch (std::out_of_range& e) {
37239       {
37240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37241       };
37242     } catch (std::exception& e) {
37243       {
37244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37245       };
37246     } catch (...) {
37247       {
37248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37249       };
37250     }
37251   }
37252   jresult = (void *)result;
37253   return jresult;
37254 }
37255
37256
37257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37258   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37259
37260   arg1 = (Dali::KeyFrames *)jarg1;
37261   {
37262     try {
37263       delete arg1;
37264     } catch (std::out_of_range& e) {
37265       {
37266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37267       };
37268     } catch (std::exception& e) {
37269       {
37270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37271       };
37272     } catch (...) {
37273       {
37274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37275       };
37276     }
37277   }
37278 }
37279
37280
37281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37282   void * jresult ;
37283   Dali::KeyFrames *arg1 = 0 ;
37284   Dali::KeyFrames *result = 0 ;
37285
37286   arg1 = (Dali::KeyFrames *)jarg1;
37287   if (!arg1) {
37288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37289     return 0;
37290   }
37291   {
37292     try {
37293       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37294     } catch (std::out_of_range& e) {
37295       {
37296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37297       };
37298     } catch (std::exception& e) {
37299       {
37300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37301       };
37302     } catch (...) {
37303       {
37304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37305       };
37306     }
37307   }
37308   jresult = (void *)result;
37309   return jresult;
37310 }
37311
37312
37313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37314   void * jresult ;
37315   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37316   Dali::KeyFrames *arg2 = 0 ;
37317   Dali::KeyFrames *result = 0 ;
37318
37319   arg1 = (Dali::KeyFrames *)jarg1;
37320   arg2 = (Dali::KeyFrames *)jarg2;
37321   if (!arg2) {
37322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37323     return 0;
37324   }
37325   {
37326     try {
37327       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37328     } catch (std::out_of_range& e) {
37329       {
37330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37331       };
37332     } catch (std::exception& e) {
37333       {
37334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37335       };
37336     } catch (...) {
37337       {
37338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37339       };
37340     }
37341   }
37342   jresult = (void *)result;
37343   return jresult;
37344 }
37345
37346
37347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37348   int jresult ;
37349   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37350   Dali::Property::Type result;
37351
37352   arg1 = (Dali::KeyFrames *)jarg1;
37353   {
37354     try {
37355       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37356     } catch (std::out_of_range& e) {
37357       {
37358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37359       };
37360     } catch (std::exception& e) {
37361       {
37362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37363       };
37364     } catch (...) {
37365       {
37366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37367       };
37368     }
37369   }
37370   jresult = (int)result;
37371   return jresult;
37372 }
37373
37374
37375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37376   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37377   float arg2 ;
37378   Dali::Property::Value arg3 ;
37379   Dali::Property::Value *argp3 ;
37380
37381   arg1 = (Dali::KeyFrames *)jarg1;
37382   arg2 = (float)jarg2;
37383   argp3 = (Dali::Property::Value *)jarg3;
37384   if (!argp3) {
37385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37386     return ;
37387   }
37388   arg3 = *argp3;
37389   {
37390     try {
37391       (arg1)->Add(arg2,arg3);
37392     } catch (std::out_of_range& e) {
37393       {
37394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37395       };
37396     } catch (std::exception& e) {
37397       {
37398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37399       };
37400     } catch (...) {
37401       {
37402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37403       };
37404     }
37405   }
37406 }
37407
37408
37409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37410   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37411   float arg2 ;
37412   Dali::Property::Value arg3 ;
37413   Dali::AlphaFunction arg4 ;
37414   Dali::Property::Value *argp3 ;
37415   Dali::AlphaFunction *argp4 ;
37416
37417   arg1 = (Dali::KeyFrames *)jarg1;
37418   arg2 = (float)jarg2;
37419   argp3 = (Dali::Property::Value *)jarg3;
37420   if (!argp3) {
37421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37422     return ;
37423   }
37424   arg3 = *argp3;
37425   argp4 = (Dali::AlphaFunction *)jarg4;
37426   if (!argp4) {
37427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37428     return ;
37429   }
37430   arg4 = *argp4;
37431   {
37432     try {
37433       (arg1)->Add(arg2,arg3,arg4);
37434     } catch (std::out_of_range& e) {
37435       {
37436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37437       };
37438     } catch (std::exception& e) {
37439       {
37440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37441       };
37442     } catch (...) {
37443       {
37444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37445       };
37446     }
37447   }
37448 }
37449
37450
37451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37452   int jresult ;
37453   int result;
37454
37455   result = (int)Dali::Path::Property::POINTS;
37456   jresult = (int)result;
37457   return jresult;
37458 }
37459
37460
37461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37462   int jresult ;
37463   int result;
37464
37465   result = (int)Dali::Path::Property::CONTROL_POINTS;
37466   jresult = (int)result;
37467   return jresult;
37468 }
37469
37470
37471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37472   void * jresult ;
37473   Dali::Path::Property *result = 0 ;
37474
37475   {
37476     try {
37477       result = (Dali::Path::Property *)new Dali::Path::Property();
37478     } catch (std::out_of_range& e) {
37479       {
37480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37481       };
37482     } catch (std::exception& e) {
37483       {
37484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37485       };
37486     } catch (...) {
37487       {
37488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37489       };
37490     }
37491   }
37492   jresult = (void *)result;
37493   return jresult;
37494 }
37495
37496
37497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37498   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37499
37500   arg1 = (Dali::Path::Property *)jarg1;
37501   {
37502     try {
37503       delete arg1;
37504     } catch (std::out_of_range& e) {
37505       {
37506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37507       };
37508     } catch (std::exception& e) {
37509       {
37510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37511       };
37512     } catch (...) {
37513       {
37514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37515       };
37516     }
37517   }
37518 }
37519
37520
37521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37522   void * jresult ;
37523   Dali::Path result;
37524
37525   {
37526     try {
37527       result = Dali::Path::New();
37528     } catch (std::out_of_range& e) {
37529       {
37530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37531       };
37532     } catch (std::exception& e) {
37533       {
37534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37535       };
37536     } catch (...) {
37537       {
37538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37539       };
37540     }
37541   }
37542   jresult = new Dali::Path((const Dali::Path &)result);
37543   return jresult;
37544 }
37545
37546
37547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37548   void * jresult ;
37549   Dali::BaseHandle arg1 ;
37550   Dali::BaseHandle *argp1 ;
37551   Dali::Path result;
37552
37553   argp1 = (Dali::BaseHandle *)jarg1;
37554   if (!argp1) {
37555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37556     return 0;
37557   }
37558   arg1 = *argp1;
37559   {
37560     try {
37561       result = Dali::Path::DownCast(arg1);
37562     } catch (std::out_of_range& e) {
37563       {
37564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37565       };
37566     } catch (std::exception& e) {
37567       {
37568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37569       };
37570     } catch (...) {
37571       {
37572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37573       };
37574     }
37575   }
37576   jresult = new Dali::Path((const Dali::Path &)result);
37577   return jresult;
37578 }
37579
37580
37581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37582   void * jresult ;
37583   Dali::Path *result = 0 ;
37584
37585   {
37586     try {
37587       result = (Dali::Path *)new Dali::Path();
37588     } catch (std::out_of_range& e) {
37589       {
37590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37591       };
37592     } catch (std::exception& e) {
37593       {
37594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37595       };
37596     } catch (...) {
37597       {
37598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37599       };
37600     }
37601   }
37602   jresult = (void *)result;
37603   return jresult;
37604 }
37605
37606
37607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
37608   Dali::Path *arg1 = (Dali::Path *) 0 ;
37609
37610   arg1 = (Dali::Path *)jarg1;
37611   {
37612     try {
37613       delete arg1;
37614     } catch (std::out_of_range& e) {
37615       {
37616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37617       };
37618     } catch (std::exception& e) {
37619       {
37620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37621       };
37622     } catch (...) {
37623       {
37624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37625       };
37626     }
37627   }
37628 }
37629
37630
37631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
37632   void * jresult ;
37633   Dali::Path *arg1 = 0 ;
37634   Dali::Path *result = 0 ;
37635
37636   arg1 = (Dali::Path *)jarg1;
37637   if (!arg1) {
37638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37639     return 0;
37640   }
37641   {
37642     try {
37643       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
37644     } catch (std::out_of_range& e) {
37645       {
37646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37647       };
37648     } catch (std::exception& e) {
37649       {
37650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37651       };
37652     } catch (...) {
37653       {
37654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37655       };
37656     }
37657   }
37658   jresult = (void *)result;
37659   return jresult;
37660 }
37661
37662
37663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
37664   void * jresult ;
37665   Dali::Path *arg1 = (Dali::Path *) 0 ;
37666   Dali::Path *arg2 = 0 ;
37667   Dali::Path *result = 0 ;
37668
37669   arg1 = (Dali::Path *)jarg1;
37670   arg2 = (Dali::Path *)jarg2;
37671   if (!arg2) {
37672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37673     return 0;
37674   }
37675   {
37676     try {
37677       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
37678     } catch (std::out_of_range& e) {
37679       {
37680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37681       };
37682     } catch (std::exception& e) {
37683       {
37684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37685       };
37686     } catch (...) {
37687       {
37688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37689       };
37690     }
37691   }
37692   jresult = (void *)result;
37693   return jresult;
37694 }
37695
37696
37697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
37698   Dali::Path *arg1 = (Dali::Path *) 0 ;
37699   Dali::Vector3 *arg2 = 0 ;
37700
37701   arg1 = (Dali::Path *)jarg1;
37702   arg2 = (Dali::Vector3 *)jarg2;
37703   if (!arg2) {
37704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37705     return ;
37706   }
37707   {
37708     try {
37709       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
37710     } catch (std::out_of_range& e) {
37711       {
37712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37713       };
37714     } catch (std::exception& e) {
37715       {
37716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37717       };
37718     } catch (...) {
37719       {
37720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37721       };
37722     }
37723   }
37724 }
37725
37726
37727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
37728   Dali::Path *arg1 = (Dali::Path *) 0 ;
37729   Dali::Vector3 *arg2 = 0 ;
37730
37731   arg1 = (Dali::Path *)jarg1;
37732   arg2 = (Dali::Vector3 *)jarg2;
37733   if (!arg2) {
37734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37735     return ;
37736   }
37737   {
37738     try {
37739       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
37740     } catch (std::out_of_range& e) {
37741       {
37742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37743       };
37744     } catch (std::exception& e) {
37745       {
37746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37747       };
37748     } catch (...) {
37749       {
37750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37751       };
37752     }
37753   }
37754 }
37755
37756
37757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
37758   Dali::Path *arg1 = (Dali::Path *) 0 ;
37759   float arg2 ;
37760
37761   arg1 = (Dali::Path *)jarg1;
37762   arg2 = (float)jarg2;
37763   {
37764     try {
37765       (arg1)->GenerateControlPoints(arg2);
37766     } catch (std::out_of_range& e) {
37767       {
37768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37769       };
37770     } catch (std::exception& e) {
37771       {
37772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37773       };
37774     } catch (...) {
37775       {
37776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37777       };
37778     }
37779   }
37780 }
37781
37782
37783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37784   Dali::Path *arg1 = (Dali::Path *) 0 ;
37785   float arg2 ;
37786   Dali::Vector3 *arg3 = 0 ;
37787   Dali::Vector3 *arg4 = 0 ;
37788
37789   arg1 = (Dali::Path *)jarg1;
37790   arg2 = (float)jarg2;
37791   arg3 = (Dali::Vector3 *)jarg3;
37792   if (!arg3) {
37793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37794     return ;
37795   }
37796   arg4 = (Dali::Vector3 *)jarg4;
37797   if (!arg4) {
37798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37799     return ;
37800   }
37801   {
37802     try {
37803       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
37804     } catch (std::out_of_range& e) {
37805       {
37806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37807       };
37808     } catch (std::exception& e) {
37809       {
37810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37811       };
37812     } catch (...) {
37813       {
37814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37815       };
37816     }
37817   }
37818 }
37819
37820
37821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
37822   void * jresult ;
37823   Dali::Path *arg1 = (Dali::Path *) 0 ;
37824   size_t arg2 ;
37825   Dali::Vector3 *result = 0 ;
37826
37827   arg1 = (Dali::Path *)jarg1;
37828   arg2 = (size_t)jarg2;
37829   {
37830     try {
37831       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
37832     } catch (std::out_of_range& e) {
37833       {
37834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37835       };
37836     } catch (std::exception& e) {
37837       {
37838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37839       };
37840     } catch (...) {
37841       {
37842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37843       };
37844     }
37845   }
37846   jresult = (void *)result;
37847   return jresult;
37848 }
37849
37850
37851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
37852   void * jresult ;
37853   Dali::Path *arg1 = (Dali::Path *) 0 ;
37854   size_t arg2 ;
37855   Dali::Vector3 *result = 0 ;
37856
37857   arg1 = (Dali::Path *)jarg1;
37858   arg2 = (size_t)jarg2;
37859   {
37860     try {
37861       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
37862     } catch (std::out_of_range& e) {
37863       {
37864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37865       };
37866     } catch (std::exception& e) {
37867       {
37868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37869       };
37870     } catch (...) {
37871       {
37872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37873       };
37874     }
37875   }
37876   jresult = (void *)result;
37877   return jresult;
37878 }
37879
37880
37881 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
37882   unsigned long jresult ;
37883   Dali::Path *arg1 = (Dali::Path *) 0 ;
37884   size_t result;
37885
37886   arg1 = (Dali::Path *)jarg1;
37887   {
37888     try {
37889       result = ((Dali::Path const *)arg1)->GetPointCount();
37890     } catch (std::out_of_range& e) {
37891       {
37892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37893       };
37894     } catch (std::exception& e) {
37895       {
37896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37897       };
37898     } catch (...) {
37899       {
37900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37901       };
37902     }
37903   }
37904   jresult = (unsigned long)result;
37905   return jresult;
37906 }
37907
37908
37909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
37910   void * jresult ;
37911   float arg1 ;
37912   Dali::TimePeriod *result = 0 ;
37913
37914   arg1 = (float)jarg1;
37915   {
37916     try {
37917       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
37918     } catch (std::out_of_range& e) {
37919       {
37920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37921       };
37922     } catch (std::exception& e) {
37923       {
37924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37925       };
37926     } catch (...) {
37927       {
37928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37929       };
37930     }
37931   }
37932   jresult = (void *)result;
37933   return jresult;
37934 }
37935
37936
37937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
37938   void * jresult ;
37939   float arg1 ;
37940   float arg2 ;
37941   Dali::TimePeriod *result = 0 ;
37942
37943   arg1 = (float)jarg1;
37944   arg2 = (float)jarg2;
37945   {
37946     try {
37947       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
37948     } catch (std::out_of_range& e) {
37949       {
37950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37951       };
37952     } catch (std::exception& e) {
37953       {
37954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37955       };
37956     } catch (...) {
37957       {
37958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37959       };
37960     }
37961   }
37962   jresult = (void *)result;
37963   return jresult;
37964 }
37965
37966
37967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
37968   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
37969
37970   arg1 = (Dali::TimePeriod *)jarg1;
37971   {
37972     try {
37973       delete arg1;
37974     } catch (std::out_of_range& e) {
37975       {
37976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37977       };
37978     } catch (std::exception& e) {
37979       {
37980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37981       };
37982     } catch (...) {
37983       {
37984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37985       };
37986     }
37987   }
37988 }
37989
37990
37991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
37992   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
37993   float arg2 ;
37994
37995   arg1 = (Dali::TimePeriod *)jarg1;
37996   arg2 = (float)jarg2;
37997   if (arg1) (arg1)->delaySeconds = arg2;
37998 }
37999
38000
38001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38002   float jresult ;
38003   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38004   float result;
38005
38006   arg1 = (Dali::TimePeriod *)jarg1;
38007   result = (float) ((arg1)->delaySeconds);
38008   jresult = result;
38009   return jresult;
38010 }
38011
38012
38013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38014   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38015   float arg2 ;
38016
38017   arg1 = (Dali::TimePeriod *)jarg1;
38018   arg2 = (float)jarg2;
38019   if (arg1) (arg1)->durationSeconds = arg2;
38020 }
38021
38022
38023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38024   float jresult ;
38025   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38026   float result;
38027
38028   arg1 = (Dali::TimePeriod *)jarg1;
38029   result = (float) ((arg1)->durationSeconds);
38030   jresult = result;
38031   return jresult;
38032 }
38033
38034
38035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38036   void * jresult ;
38037   Dali::Animation *result = 0 ;
38038
38039   {
38040     try {
38041       result = (Dali::Animation *)new Dali::Animation();
38042     } catch (std::out_of_range& e) {
38043       {
38044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38045       };
38046     } catch (std::exception& e) {
38047       {
38048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38049       };
38050     } catch (...) {
38051       {
38052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38053       };
38054     }
38055   }
38056   jresult = (void *)result;
38057   return jresult;
38058 }
38059
38060
38061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38062   void * jresult ;
38063   float arg1 ;
38064   Dali::Animation result;
38065
38066   arg1 = (float)jarg1;
38067   {
38068     try {
38069       result = Dali::Animation::New(arg1);
38070     } catch (std::out_of_range& e) {
38071       {
38072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38073       };
38074     } catch (std::exception& e) {
38075       {
38076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38077       };
38078     } catch (...) {
38079       {
38080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38081       };
38082     }
38083   }
38084   jresult = new Dali::Animation((const Dali::Animation &)result);
38085   return jresult;
38086 }
38087
38088
38089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38090   void * jresult ;
38091   Dali::BaseHandle arg1 ;
38092   Dali::BaseHandle *argp1 ;
38093   Dali::Animation result;
38094
38095   argp1 = (Dali::BaseHandle *)jarg1;
38096   if (!argp1) {
38097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38098     return 0;
38099   }
38100   arg1 = *argp1;
38101   {
38102     try {
38103       result = Dali::Animation::DownCast(arg1);
38104     } catch (std::out_of_range& e) {
38105       {
38106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38107       };
38108     } catch (std::exception& e) {
38109       {
38110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38111       };
38112     } catch (...) {
38113       {
38114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38115       };
38116     }
38117   }
38118   jresult = new Dali::Animation((const Dali::Animation &)result);
38119   return jresult;
38120 }
38121
38122
38123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38124   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38125
38126   arg1 = (Dali::Animation *)jarg1;
38127   {
38128     try {
38129       delete arg1;
38130     } catch (std::out_of_range& e) {
38131       {
38132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38133       };
38134     } catch (std::exception& e) {
38135       {
38136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38137       };
38138     } catch (...) {
38139       {
38140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38141       };
38142     }
38143   }
38144 }
38145
38146
38147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38148   void * jresult ;
38149   Dali::Animation *arg1 = 0 ;
38150   Dali::Animation *result = 0 ;
38151
38152   arg1 = (Dali::Animation *)jarg1;
38153   if (!arg1) {
38154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38155     return 0;
38156   }
38157   {
38158     try {
38159       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38160     } catch (std::out_of_range& e) {
38161       {
38162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38163       };
38164     } catch (std::exception& e) {
38165       {
38166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38167       };
38168     } catch (...) {
38169       {
38170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38171       };
38172     }
38173   }
38174   jresult = (void *)result;
38175   return jresult;
38176 }
38177
38178
38179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38180   void * jresult ;
38181   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38182   Dali::Animation *arg2 = 0 ;
38183   Dali::Animation *result = 0 ;
38184
38185   arg1 = (Dali::Animation *)jarg1;
38186   arg2 = (Dali::Animation *)jarg2;
38187   if (!arg2) {
38188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38189     return 0;
38190   }
38191   {
38192     try {
38193       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38194     } catch (std::out_of_range& e) {
38195       {
38196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38197       };
38198     } catch (std::exception& e) {
38199       {
38200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38201       };
38202     } catch (...) {
38203       {
38204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38205       };
38206     }
38207   }
38208   jresult = (void *)result;
38209   return jresult;
38210 }
38211
38212
38213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38214   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38215   float arg2 ;
38216
38217   arg1 = (Dali::Animation *)jarg1;
38218   arg2 = (float)jarg2;
38219   {
38220     try {
38221       (arg1)->SetDuration(arg2);
38222     } catch (std::out_of_range& e) {
38223       {
38224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38225       };
38226     } catch (std::exception& e) {
38227       {
38228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38229       };
38230     } catch (...) {
38231       {
38232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38233       };
38234     }
38235   }
38236 }
38237
38238
38239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38240   float jresult ;
38241   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38242   float result;
38243
38244   arg1 = (Dali::Animation *)jarg1;
38245   {
38246     try {
38247       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38248     } catch (std::out_of_range& e) {
38249       {
38250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38251       };
38252     } catch (std::exception& e) {
38253       {
38254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38255       };
38256     } catch (...) {
38257       {
38258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38259       };
38260     }
38261   }
38262   jresult = result;
38263   return jresult;
38264 }
38265
38266
38267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38268   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38269   bool arg2 ;
38270
38271   arg1 = (Dali::Animation *)jarg1;
38272   arg2 = jarg2 ? true : false;
38273   {
38274     try {
38275       (arg1)->SetLooping(arg2);
38276     } catch (std::out_of_range& e) {
38277       {
38278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38279       };
38280     } catch (std::exception& e) {
38281       {
38282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38283       };
38284     } catch (...) {
38285       {
38286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38287       };
38288     }
38289   }
38290 }
38291
38292
38293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38294   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38295   int arg2 ;
38296
38297   arg1 = (Dali::Animation *)jarg1;
38298   arg2 = (int)jarg2;
38299   {
38300     try {
38301       (arg1)->SetLoopCount(arg2);
38302     } catch (std::out_of_range& e) {
38303       {
38304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38305       };
38306     } catch (std::exception& e) {
38307       {
38308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38309       };
38310     } catch (...) {
38311       {
38312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38313       };
38314     }
38315   }
38316 }
38317
38318
38319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38320   int jresult ;
38321   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38322   int result;
38323
38324   arg1 = (Dali::Animation *)jarg1;
38325   {
38326     try {
38327       result = (int)(arg1)->GetLoopCount();
38328     } catch (std::out_of_range& e) {
38329       {
38330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38331       };
38332     } catch (std::exception& e) {
38333       {
38334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38335       };
38336     } catch (...) {
38337       {
38338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38339       };
38340     }
38341   }
38342   jresult = result;
38343   return jresult;
38344 }
38345
38346
38347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38348   int jresult ;
38349   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38350   int result;
38351
38352   arg1 = (Dali::Animation *)jarg1;
38353   {
38354     try {
38355       result = (int)(arg1)->GetCurrentLoop();
38356     } catch (std::out_of_range& e) {
38357       {
38358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38359       };
38360     } catch (std::exception& e) {
38361       {
38362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38363       };
38364     } catch (...) {
38365       {
38366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38367       };
38368     }
38369   }
38370   jresult = result;
38371   return jresult;
38372 }
38373
38374
38375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38376   unsigned int jresult ;
38377   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38378   bool result;
38379
38380   arg1 = (Dali::Animation *)jarg1;
38381   {
38382     try {
38383       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38384     } catch (std::out_of_range& e) {
38385       {
38386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38387       };
38388     } catch (std::exception& e) {
38389       {
38390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38391       };
38392     } catch (...) {
38393       {
38394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38395       };
38396     }
38397   }
38398   jresult = result;
38399   return jresult;
38400 }
38401
38402
38403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38404   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38405   Dali::Animation::EndAction arg2 ;
38406
38407   arg1 = (Dali::Animation *)jarg1;
38408   arg2 = (Dali::Animation::EndAction)jarg2;
38409   {
38410     try {
38411       (arg1)->SetEndAction(arg2);
38412     } catch (std::out_of_range& e) {
38413       {
38414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38415       };
38416     } catch (std::exception& e) {
38417       {
38418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38419       };
38420     } catch (...) {
38421       {
38422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38423       };
38424     }
38425   }
38426 }
38427
38428
38429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38430   int jresult ;
38431   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38432   Dali::Animation::EndAction result;
38433
38434   arg1 = (Dali::Animation *)jarg1;
38435   {
38436     try {
38437       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38438     } catch (std::out_of_range& e) {
38439       {
38440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38441       };
38442     } catch (std::exception& e) {
38443       {
38444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38445       };
38446     } catch (...) {
38447       {
38448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38449       };
38450     }
38451   }
38452   jresult = (int)result;
38453   return jresult;
38454 }
38455
38456
38457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38458   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38459   Dali::Animation::EndAction arg2 ;
38460
38461   arg1 = (Dali::Animation *)jarg1;
38462   arg2 = (Dali::Animation::EndAction)jarg2;
38463   {
38464     try {
38465       (arg1)->SetDisconnectAction(arg2);
38466     } catch (std::out_of_range& e) {
38467       {
38468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38469       };
38470     } catch (std::exception& e) {
38471       {
38472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38473       };
38474     } catch (...) {
38475       {
38476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38477       };
38478     }
38479   }
38480 }
38481
38482
38483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38484   int jresult ;
38485   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38486   Dali::Animation::EndAction result;
38487
38488   arg1 = (Dali::Animation *)jarg1;
38489   {
38490     try {
38491       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38492     } catch (std::out_of_range& e) {
38493       {
38494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38495       };
38496     } catch (std::exception& e) {
38497       {
38498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38499       };
38500     } catch (...) {
38501       {
38502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38503       };
38504     }
38505   }
38506   jresult = (int)result;
38507   return jresult;
38508 }
38509
38510
38511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38512   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38513   Dali::AlphaFunction arg2 ;
38514   Dali::AlphaFunction *argp2 ;
38515
38516   arg1 = (Dali::Animation *)jarg1;
38517   argp2 = (Dali::AlphaFunction *)jarg2;
38518   if (!argp2) {
38519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38520     return ;
38521   }
38522   arg2 = *argp2;
38523   {
38524     try {
38525       (arg1)->SetDefaultAlphaFunction(arg2);
38526     } catch (std::out_of_range& e) {
38527       {
38528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38529       };
38530     } catch (std::exception& e) {
38531       {
38532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38533       };
38534     } catch (...) {
38535       {
38536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38537       };
38538     }
38539   }
38540 }
38541
38542
38543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38544   void * jresult ;
38545   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38546   Dali::AlphaFunction result;
38547
38548   arg1 = (Dali::Animation *)jarg1;
38549   {
38550     try {
38551       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38552     } catch (std::out_of_range& e) {
38553       {
38554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38555       };
38556     } catch (std::exception& e) {
38557       {
38558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38559       };
38560     } catch (...) {
38561       {
38562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38563       };
38564     }
38565   }
38566   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38567   return jresult;
38568 }
38569
38570
38571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38572   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38573   float arg2 ;
38574
38575   arg1 = (Dali::Animation *)jarg1;
38576   arg2 = (float)jarg2;
38577   {
38578     try {
38579       (arg1)->SetCurrentProgress(arg2);
38580     } catch (std::out_of_range& e) {
38581       {
38582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38583       };
38584     } catch (std::exception& e) {
38585       {
38586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38587       };
38588     } catch (...) {
38589       {
38590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38591       };
38592     }
38593   }
38594 }
38595
38596
38597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
38598   float jresult ;
38599   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38600   float result;
38601
38602   arg1 = (Dali::Animation *)jarg1;
38603   {
38604     try {
38605       result = (float)(arg1)->GetCurrentProgress();
38606     } catch (std::out_of_range& e) {
38607       {
38608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38609       };
38610     } catch (std::exception& e) {
38611       {
38612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38613       };
38614     } catch (...) {
38615       {
38616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38617       };
38618     }
38619   }
38620   jresult = result;
38621   return jresult;
38622 }
38623
38624
38625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
38626   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38627   float arg2 ;
38628
38629   arg1 = (Dali::Animation *)jarg1;
38630   arg2 = (float)jarg2;
38631   {
38632     try {
38633       (arg1)->SetSpeedFactor(arg2);
38634     } catch (std::out_of_range& e) {
38635       {
38636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38637       };
38638     } catch (std::exception& e) {
38639       {
38640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38641       };
38642     } catch (...) {
38643       {
38644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38645       };
38646     }
38647   }
38648 }
38649
38650
38651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
38652   float jresult ;
38653   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38654   float result;
38655
38656   arg1 = (Dali::Animation *)jarg1;
38657   {
38658     try {
38659       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
38660     } catch (std::out_of_range& e) {
38661       {
38662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38663       };
38664     } catch (std::exception& e) {
38665       {
38666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38667       };
38668     } catch (...) {
38669       {
38670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38671       };
38672     }
38673   }
38674   jresult = result;
38675   return jresult;
38676 }
38677
38678
38679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
38680   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38681   Dali::Vector2 *arg2 = 0 ;
38682
38683   arg1 = (Dali::Animation *)jarg1;
38684   arg2 = (Dali::Vector2 *)jarg2;
38685   if (!arg2) {
38686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38687     return ;
38688   }
38689   {
38690     try {
38691       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
38692     } catch (std::out_of_range& e) {
38693       {
38694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38695       };
38696     } catch (std::exception& e) {
38697       {
38698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38699       };
38700     } catch (...) {
38701       {
38702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38703       };
38704     }
38705   }
38706 }
38707
38708
38709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
38710   void * jresult ;
38711   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38712   Dali::Vector2 result;
38713
38714   arg1 = (Dali::Animation *)jarg1;
38715   {
38716     try {
38717       result = ((Dali::Animation const *)arg1)->GetPlayRange();
38718     } catch (std::out_of_range& e) {
38719       {
38720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38721       };
38722     } catch (std::exception& e) {
38723       {
38724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38725       };
38726     } catch (...) {
38727       {
38728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38729       };
38730     }
38731   }
38732   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38733   return jresult;
38734 }
38735
38736
38737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
38738   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38739
38740   arg1 = (Dali::Animation *)jarg1;
38741   {
38742     try {
38743       (arg1)->Play();
38744     } catch (std::out_of_range& e) {
38745       {
38746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38747       };
38748     } catch (std::exception& e) {
38749       {
38750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38751       };
38752     } catch (...) {
38753       {
38754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38755       };
38756     }
38757   }
38758 }
38759
38760
38761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
38762   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38763   float arg2 ;
38764
38765   arg1 = (Dali::Animation *)jarg1;
38766   arg2 = (float)jarg2;
38767   {
38768     try {
38769       (arg1)->PlayFrom(arg2);
38770     } catch (std::out_of_range& e) {
38771       {
38772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38773       };
38774     } catch (std::exception& e) {
38775       {
38776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38777       };
38778     } catch (...) {
38779       {
38780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38781       };
38782     }
38783   }
38784 }
38785
38786
38787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
38788   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38789
38790   arg1 = (Dali::Animation *)jarg1;
38791   {
38792     try {
38793       (arg1)->Pause();
38794     } catch (std::out_of_range& e) {
38795       {
38796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38797       };
38798     } catch (std::exception& e) {
38799       {
38800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38801       };
38802     } catch (...) {
38803       {
38804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38805       };
38806     }
38807   }
38808 }
38809
38810
38811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
38812   int jresult ;
38813   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38814   Dali::Animation::State result;
38815
38816   arg1 = (Dali::Animation *)jarg1;
38817   {
38818     try {
38819       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
38820     } catch (std::out_of_range& e) {
38821       {
38822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38823       };
38824     } catch (std::exception& e) {
38825       {
38826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38827       };
38828     } catch (...) {
38829       {
38830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38831       };
38832     }
38833   }
38834   jresult = (int)result;
38835   return jresult;
38836 }
38837
38838
38839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
38840   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38841
38842   arg1 = (Dali::Animation *)jarg1;
38843   {
38844     try {
38845       (arg1)->Stop();
38846     } catch (std::out_of_range& e) {
38847       {
38848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38849       };
38850     } catch (std::exception& e) {
38851       {
38852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38853       };
38854     } catch (...) {
38855       {
38856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38857       };
38858     }
38859   }
38860 }
38861
38862
38863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
38864   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38865
38866   arg1 = (Dali::Animation *)jarg1;
38867   {
38868     try {
38869       (arg1)->Clear();
38870     } catch (std::out_of_range& e) {
38871       {
38872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38873       };
38874     } catch (std::exception& e) {
38875       {
38876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38877       };
38878     } catch (...) {
38879       {
38880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38881       };
38882     }
38883   }
38884 }
38885
38886
38887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
38888   void * jresult ;
38889   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38890   Dali::Animation::AnimationSignalType *result = 0 ;
38891
38892   arg1 = (Dali::Animation *)jarg1;
38893   {
38894     try {
38895       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
38896     } catch (std::out_of_range& e) {
38897       {
38898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38899       };
38900     } catch (std::exception& e) {
38901       {
38902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38903       };
38904     } catch (...) {
38905       {
38906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38907       };
38908     }
38909   }
38910   jresult = (void *)result;
38911   return jresult;
38912 }
38913
38914
38915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
38916   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38917   SwigValueWrapper< Dali::Property > arg2 ;
38918   Dali::Property::Value arg3 ;
38919   Dali::Property *argp2 ;
38920   Dali::Property::Value *argp3 ;
38921
38922   arg1 = (Dali::Animation *)jarg1;
38923   argp2 = (Dali::Property *)jarg2;
38924   if (!argp2) {
38925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38926     return ;
38927   }
38928   arg2 = *argp2;
38929   argp3 = (Dali::Property::Value *)jarg3;
38930   if (!argp3) {
38931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38932     return ;
38933   }
38934   arg3 = *argp3;
38935   {
38936     try {
38937       (arg1)->AnimateBy(arg2,arg3);
38938     } catch (std::out_of_range& e) {
38939       {
38940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38941       };
38942     } catch (std::exception& e) {
38943       {
38944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38945       };
38946     } catch (...) {
38947       {
38948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38949       };
38950     }
38951   }
38952 }
38953
38954
38955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
38956   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38957   SwigValueWrapper< Dali::Property > arg2 ;
38958   Dali::Property::Value arg3 ;
38959   Dali::AlphaFunction arg4 ;
38960   Dali::Property *argp2 ;
38961   Dali::Property::Value *argp3 ;
38962   Dali::AlphaFunction *argp4 ;
38963
38964   arg1 = (Dali::Animation *)jarg1;
38965   argp2 = (Dali::Property *)jarg2;
38966   if (!argp2) {
38967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38968     return ;
38969   }
38970   arg2 = *argp2;
38971   argp3 = (Dali::Property::Value *)jarg3;
38972   if (!argp3) {
38973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38974     return ;
38975   }
38976   arg3 = *argp3;
38977   argp4 = (Dali::AlphaFunction *)jarg4;
38978   if (!argp4) {
38979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38980     return ;
38981   }
38982   arg4 = *argp4;
38983   {
38984     try {
38985       (arg1)->AnimateBy(arg2,arg3,arg4);
38986     } catch (std::out_of_range& e) {
38987       {
38988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38989       };
38990     } catch (std::exception& e) {
38991       {
38992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38993       };
38994     } catch (...) {
38995       {
38996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38997       };
38998     }
38999   }
39000 }
39001
39002
39003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39004   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39005   SwigValueWrapper< Dali::Property > arg2 ;
39006   Dali::Property::Value arg3 ;
39007   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39008   Dali::Property *argp2 ;
39009   Dali::Property::Value *argp3 ;
39010   Dali::TimePeriod *argp4 ;
39011
39012   arg1 = (Dali::Animation *)jarg1;
39013   argp2 = (Dali::Property *)jarg2;
39014   if (!argp2) {
39015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39016     return ;
39017   }
39018   arg2 = *argp2;
39019   argp3 = (Dali::Property::Value *)jarg3;
39020   if (!argp3) {
39021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39022     return ;
39023   }
39024   arg3 = *argp3;
39025   argp4 = (Dali::TimePeriod *)jarg4;
39026   if (!argp4) {
39027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39028     return ;
39029   }
39030   arg4 = *argp4;
39031   {
39032     try {
39033       (arg1)->AnimateBy(arg2,arg3,arg4);
39034     } catch (std::out_of_range& e) {
39035       {
39036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39037       };
39038     } catch (std::exception& e) {
39039       {
39040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39041       };
39042     } catch (...) {
39043       {
39044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39045       };
39046     }
39047   }
39048 }
39049
39050
39051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39052   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39053   SwigValueWrapper< Dali::Property > arg2 ;
39054   Dali::Property::Value arg3 ;
39055   Dali::AlphaFunction arg4 ;
39056   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39057   Dali::Property *argp2 ;
39058   Dali::Property::Value *argp3 ;
39059   Dali::AlphaFunction *argp4 ;
39060   Dali::TimePeriod *argp5 ;
39061
39062   arg1 = (Dali::Animation *)jarg1;
39063   argp2 = (Dali::Property *)jarg2;
39064   if (!argp2) {
39065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39066     return ;
39067   }
39068   arg2 = *argp2;
39069   argp3 = (Dali::Property::Value *)jarg3;
39070   if (!argp3) {
39071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39072     return ;
39073   }
39074   arg3 = *argp3;
39075   argp4 = (Dali::AlphaFunction *)jarg4;
39076   if (!argp4) {
39077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39078     return ;
39079   }
39080   arg4 = *argp4;
39081   argp5 = (Dali::TimePeriod *)jarg5;
39082   if (!argp5) {
39083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39084     return ;
39085   }
39086   arg5 = *argp5;
39087   {
39088     try {
39089       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39090     } catch (std::out_of_range& e) {
39091       {
39092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39093       };
39094     } catch (std::exception& e) {
39095       {
39096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39097       };
39098     } catch (...) {
39099       {
39100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39101       };
39102     }
39103   }
39104 }
39105
39106
39107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39108   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39109   SwigValueWrapper< Dali::Property > arg2 ;
39110   Dali::Property::Value arg3 ;
39111   Dali::Property *argp2 ;
39112   Dali::Property::Value *argp3 ;
39113
39114   arg1 = (Dali::Animation *)jarg1;
39115   argp2 = (Dali::Property *)jarg2;
39116   if (!argp2) {
39117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39118     return ;
39119   }
39120   arg2 = *argp2;
39121   argp3 = (Dali::Property::Value *)jarg3;
39122   if (!argp3) {
39123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39124     return ;
39125   }
39126   arg3 = *argp3;
39127   {
39128     try {
39129       (arg1)->AnimateTo(arg2,arg3);
39130     } catch (std::out_of_range& e) {
39131       {
39132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39133       };
39134     } catch (std::exception& e) {
39135       {
39136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39137       };
39138     } catch (...) {
39139       {
39140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39141       };
39142     }
39143   }
39144 }
39145
39146
39147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39148   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39149   SwigValueWrapper< Dali::Property > arg2 ;
39150   Dali::Property::Value arg3 ;
39151   Dali::AlphaFunction arg4 ;
39152   Dali::Property *argp2 ;
39153   Dali::Property::Value *argp3 ;
39154   Dali::AlphaFunction *argp4 ;
39155
39156   arg1 = (Dali::Animation *)jarg1;
39157   argp2 = (Dali::Property *)jarg2;
39158   if (!argp2) {
39159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39160     return ;
39161   }
39162   arg2 = *argp2;
39163   argp3 = (Dali::Property::Value *)jarg3;
39164   if (!argp3) {
39165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39166     return ;
39167   }
39168   arg3 = *argp3;
39169   argp4 = (Dali::AlphaFunction *)jarg4;
39170   if (!argp4) {
39171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39172     return ;
39173   }
39174   arg4 = *argp4;
39175   {
39176     try {
39177       (arg1)->AnimateTo(arg2,arg3,arg4);
39178     } catch (std::out_of_range& e) {
39179       {
39180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39181       };
39182     } catch (std::exception& e) {
39183       {
39184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39185       };
39186     } catch (...) {
39187       {
39188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39189       };
39190     }
39191   }
39192 }
39193
39194
39195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39196   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39197   SwigValueWrapper< Dali::Property > arg2 ;
39198   Dali::Property::Value arg3 ;
39199   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39200   Dali::Property *argp2 ;
39201   Dali::Property::Value *argp3 ;
39202   Dali::TimePeriod *argp4 ;
39203
39204   arg1 = (Dali::Animation *)jarg1;
39205   argp2 = (Dali::Property *)jarg2;
39206   if (!argp2) {
39207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39208     return ;
39209   }
39210   arg2 = *argp2;
39211   argp3 = (Dali::Property::Value *)jarg3;
39212   if (!argp3) {
39213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39214     return ;
39215   }
39216   arg3 = *argp3;
39217   argp4 = (Dali::TimePeriod *)jarg4;
39218   if (!argp4) {
39219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39220     return ;
39221   }
39222   arg4 = *argp4;
39223   {
39224     try {
39225       (arg1)->AnimateTo(arg2,arg3,arg4);
39226     } catch (std::out_of_range& e) {
39227       {
39228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39229       };
39230     } catch (std::exception& e) {
39231       {
39232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39233       };
39234     } catch (...) {
39235       {
39236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39237       };
39238     }
39239   }
39240 }
39241
39242
39243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39244   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39245   SwigValueWrapper< Dali::Property > arg2 ;
39246   Dali::Property::Value arg3 ;
39247   Dali::AlphaFunction arg4 ;
39248   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39249   Dali::Property *argp2 ;
39250   Dali::Property::Value *argp3 ;
39251   Dali::AlphaFunction *argp4 ;
39252   Dali::TimePeriod *argp5 ;
39253
39254   arg1 = (Dali::Animation *)jarg1;
39255   argp2 = (Dali::Property *)jarg2;
39256   if (!argp2) {
39257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39258     return ;
39259   }
39260   arg2 = *argp2;
39261   argp3 = (Dali::Property::Value *)jarg3;
39262   if (!argp3) {
39263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39264     return ;
39265   }
39266   arg3 = *argp3;
39267   argp4 = (Dali::AlphaFunction *)jarg4;
39268   if (!argp4) {
39269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39270     return ;
39271   }
39272   arg4 = *argp4;
39273   argp5 = (Dali::TimePeriod *)jarg5;
39274   if (!argp5) {
39275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39276     return ;
39277   }
39278   arg5 = *argp5;
39279   {
39280     try {
39281       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39282     } catch (std::out_of_range& e) {
39283       {
39284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39285       };
39286     } catch (std::exception& e) {
39287       {
39288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39289       };
39290     } catch (...) {
39291       {
39292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39293       };
39294     }
39295   }
39296 }
39297
39298
39299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39300   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39301   SwigValueWrapper< Dali::Property > arg2 ;
39302   Dali::KeyFrames *arg3 = 0 ;
39303   Dali::Property *argp2 ;
39304
39305   arg1 = (Dali::Animation *)jarg1;
39306   argp2 = (Dali::Property *)jarg2;
39307   if (!argp2) {
39308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39309     return ;
39310   }
39311   arg2 = *argp2;
39312   arg3 = (Dali::KeyFrames *)jarg3;
39313   if (!arg3) {
39314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39315     return ;
39316   }
39317   {
39318     try {
39319       (arg1)->AnimateBetween(arg2,*arg3);
39320     } catch (std::out_of_range& e) {
39321       {
39322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39323       };
39324     } catch (std::exception& e) {
39325       {
39326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39327       };
39328     } catch (...) {
39329       {
39330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39331       };
39332     }
39333   }
39334 }
39335
39336
39337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39338   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39339   SwigValueWrapper< Dali::Property > arg2 ;
39340   Dali::KeyFrames *arg3 = 0 ;
39341   Dali::Animation::Interpolation arg4 ;
39342   Dali::Property *argp2 ;
39343
39344   arg1 = (Dali::Animation *)jarg1;
39345   argp2 = (Dali::Property *)jarg2;
39346   if (!argp2) {
39347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39348     return ;
39349   }
39350   arg2 = *argp2;
39351   arg3 = (Dali::KeyFrames *)jarg3;
39352   if (!arg3) {
39353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39354     return ;
39355   }
39356   arg4 = (Dali::Animation::Interpolation)jarg4;
39357   {
39358     try {
39359       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39360     } catch (std::out_of_range& e) {
39361       {
39362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39363       };
39364     } catch (std::exception& e) {
39365       {
39366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39367       };
39368     } catch (...) {
39369       {
39370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39371       };
39372     }
39373   }
39374 }
39375
39376
39377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39378   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39379   SwigValueWrapper< Dali::Property > arg2 ;
39380   Dali::KeyFrames *arg3 = 0 ;
39381   Dali::AlphaFunction arg4 ;
39382   Dali::Property *argp2 ;
39383   Dali::AlphaFunction *argp4 ;
39384
39385   arg1 = (Dali::Animation *)jarg1;
39386   argp2 = (Dali::Property *)jarg2;
39387   if (!argp2) {
39388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39389     return ;
39390   }
39391   arg2 = *argp2;
39392   arg3 = (Dali::KeyFrames *)jarg3;
39393   if (!arg3) {
39394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39395     return ;
39396   }
39397   argp4 = (Dali::AlphaFunction *)jarg4;
39398   if (!argp4) {
39399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39400     return ;
39401   }
39402   arg4 = *argp4;
39403   {
39404     try {
39405       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39406     } catch (std::out_of_range& e) {
39407       {
39408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39409       };
39410     } catch (std::exception& e) {
39411       {
39412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39413       };
39414     } catch (...) {
39415       {
39416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39417       };
39418     }
39419   }
39420 }
39421
39422
39423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39424   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39425   SwigValueWrapper< Dali::Property > arg2 ;
39426   Dali::KeyFrames *arg3 = 0 ;
39427   Dali::AlphaFunction arg4 ;
39428   Dali::Animation::Interpolation arg5 ;
39429   Dali::Property *argp2 ;
39430   Dali::AlphaFunction *argp4 ;
39431
39432   arg1 = (Dali::Animation *)jarg1;
39433   argp2 = (Dali::Property *)jarg2;
39434   if (!argp2) {
39435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39436     return ;
39437   }
39438   arg2 = *argp2;
39439   arg3 = (Dali::KeyFrames *)jarg3;
39440   if (!arg3) {
39441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39442     return ;
39443   }
39444   argp4 = (Dali::AlphaFunction *)jarg4;
39445   if (!argp4) {
39446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39447     return ;
39448   }
39449   arg4 = *argp4;
39450   arg5 = (Dali::Animation::Interpolation)jarg5;
39451   {
39452     try {
39453       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39454     } catch (std::out_of_range& e) {
39455       {
39456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39457       };
39458     } catch (std::exception& e) {
39459       {
39460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39461       };
39462     } catch (...) {
39463       {
39464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39465       };
39466     }
39467   }
39468 }
39469
39470
39471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39472   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39473   SwigValueWrapper< Dali::Property > arg2 ;
39474   Dali::KeyFrames *arg3 = 0 ;
39475   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39476   Dali::Property *argp2 ;
39477   Dali::TimePeriod *argp4 ;
39478
39479   arg1 = (Dali::Animation *)jarg1;
39480   argp2 = (Dali::Property *)jarg2;
39481   if (!argp2) {
39482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39483     return ;
39484   }
39485   arg2 = *argp2;
39486   arg3 = (Dali::KeyFrames *)jarg3;
39487   if (!arg3) {
39488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39489     return ;
39490   }
39491   argp4 = (Dali::TimePeriod *)jarg4;
39492   if (!argp4) {
39493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39494     return ;
39495   }
39496   arg4 = *argp4;
39497   {
39498     try {
39499       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39500     } catch (std::out_of_range& e) {
39501       {
39502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39503       };
39504     } catch (std::exception& e) {
39505       {
39506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39507       };
39508     } catch (...) {
39509       {
39510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39511       };
39512     }
39513   }
39514 }
39515
39516
39517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39518   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39519   SwigValueWrapper< Dali::Property > arg2 ;
39520   Dali::KeyFrames *arg3 = 0 ;
39521   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39522   Dali::Animation::Interpolation arg5 ;
39523   Dali::Property *argp2 ;
39524   Dali::TimePeriod *argp4 ;
39525
39526   arg1 = (Dali::Animation *)jarg1;
39527   argp2 = (Dali::Property *)jarg2;
39528   if (!argp2) {
39529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39530     return ;
39531   }
39532   arg2 = *argp2;
39533   arg3 = (Dali::KeyFrames *)jarg3;
39534   if (!arg3) {
39535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39536     return ;
39537   }
39538   argp4 = (Dali::TimePeriod *)jarg4;
39539   if (!argp4) {
39540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39541     return ;
39542   }
39543   arg4 = *argp4;
39544   arg5 = (Dali::Animation::Interpolation)jarg5;
39545   {
39546     try {
39547       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39548     } catch (std::out_of_range& e) {
39549       {
39550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39551       };
39552     } catch (std::exception& e) {
39553       {
39554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39555       };
39556     } catch (...) {
39557       {
39558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39559       };
39560     }
39561   }
39562 }
39563
39564
39565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39566   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39567   SwigValueWrapper< Dali::Property > arg2 ;
39568   Dali::KeyFrames *arg3 = 0 ;
39569   Dali::AlphaFunction arg4 ;
39570   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39571   Dali::Property *argp2 ;
39572   Dali::AlphaFunction *argp4 ;
39573   Dali::TimePeriod *argp5 ;
39574
39575   arg1 = (Dali::Animation *)jarg1;
39576   argp2 = (Dali::Property *)jarg2;
39577   if (!argp2) {
39578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39579     return ;
39580   }
39581   arg2 = *argp2;
39582   arg3 = (Dali::KeyFrames *)jarg3;
39583   if (!arg3) {
39584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39585     return ;
39586   }
39587   argp4 = (Dali::AlphaFunction *)jarg4;
39588   if (!argp4) {
39589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39590     return ;
39591   }
39592   arg4 = *argp4;
39593   argp5 = (Dali::TimePeriod *)jarg5;
39594   if (!argp5) {
39595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39596     return ;
39597   }
39598   arg5 = *argp5;
39599   {
39600     try {
39601       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39602     } catch (std::out_of_range& e) {
39603       {
39604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39605       };
39606     } catch (std::exception& e) {
39607       {
39608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39609       };
39610     } catch (...) {
39611       {
39612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39613       };
39614     }
39615   }
39616 }
39617
39618
39619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
39620   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39621   SwigValueWrapper< Dali::Property > arg2 ;
39622   Dali::KeyFrames *arg3 = 0 ;
39623   Dali::AlphaFunction arg4 ;
39624   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39625   Dali::Animation::Interpolation arg6 ;
39626   Dali::Property *argp2 ;
39627   Dali::AlphaFunction *argp4 ;
39628   Dali::TimePeriod *argp5 ;
39629
39630   arg1 = (Dali::Animation *)jarg1;
39631   argp2 = (Dali::Property *)jarg2;
39632   if (!argp2) {
39633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39634     return ;
39635   }
39636   arg2 = *argp2;
39637   arg3 = (Dali::KeyFrames *)jarg3;
39638   if (!arg3) {
39639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39640     return ;
39641   }
39642   argp4 = (Dali::AlphaFunction *)jarg4;
39643   if (!argp4) {
39644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39645     return ;
39646   }
39647   arg4 = *argp4;
39648   argp5 = (Dali::TimePeriod *)jarg5;
39649   if (!argp5) {
39650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39651     return ;
39652   }
39653   arg5 = *argp5;
39654   arg6 = (Dali::Animation::Interpolation)jarg6;
39655   {
39656     try {
39657       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
39658     } catch (std::out_of_range& e) {
39659       {
39660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39661       };
39662     } catch (std::exception& e) {
39663       {
39664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39665       };
39666     } catch (...) {
39667       {
39668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39669       };
39670     }
39671   }
39672 }
39673
39674
39675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39676   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39677   Dali::Actor arg2 ;
39678   Dali::Path arg3 ;
39679   Dali::Vector3 *arg4 = 0 ;
39680   Dali::Actor *argp2 ;
39681   Dali::Path *argp3 ;
39682
39683   arg1 = (Dali::Animation *)jarg1;
39684   argp2 = (Dali::Actor *)jarg2;
39685   if (!argp2) {
39686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39687     return ;
39688   }
39689   arg2 = *argp2;
39690   argp3 = (Dali::Path *)jarg3;
39691   if (!argp3) {
39692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39693     return ;
39694   }
39695   arg3 = *argp3;
39696   arg4 = (Dali::Vector3 *)jarg4;
39697   if (!arg4) {
39698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39699     return ;
39700   }
39701   {
39702     try {
39703       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
39704     } catch (std::out_of_range& e) {
39705       {
39706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39707       };
39708     } catch (std::exception& e) {
39709       {
39710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39711       };
39712     } catch (...) {
39713       {
39714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39715       };
39716     }
39717   }
39718 }
39719
39720
39721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39722   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39723   Dali::Actor arg2 ;
39724   Dali::Path arg3 ;
39725   Dali::Vector3 *arg4 = 0 ;
39726   Dali::AlphaFunction arg5 ;
39727   Dali::Actor *argp2 ;
39728   Dali::Path *argp3 ;
39729   Dali::AlphaFunction *argp5 ;
39730
39731   arg1 = (Dali::Animation *)jarg1;
39732   argp2 = (Dali::Actor *)jarg2;
39733   if (!argp2) {
39734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39735     return ;
39736   }
39737   arg2 = *argp2;
39738   argp3 = (Dali::Path *)jarg3;
39739   if (!argp3) {
39740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39741     return ;
39742   }
39743   arg3 = *argp3;
39744   arg4 = (Dali::Vector3 *)jarg4;
39745   if (!arg4) {
39746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39747     return ;
39748   }
39749   argp5 = (Dali::AlphaFunction *)jarg5;
39750   if (!argp5) {
39751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39752     return ;
39753   }
39754   arg5 = *argp5;
39755   {
39756     try {
39757       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
39758     } catch (std::out_of_range& e) {
39759       {
39760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39761       };
39762     } catch (std::exception& e) {
39763       {
39764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39765       };
39766     } catch (...) {
39767       {
39768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39769       };
39770     }
39771   }
39772 }
39773
39774
39775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39776   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39777   Dali::Actor arg2 ;
39778   Dali::Path arg3 ;
39779   Dali::Vector3 *arg4 = 0 ;
39780   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39781   Dali::Actor *argp2 ;
39782   Dali::Path *argp3 ;
39783   Dali::TimePeriod *argp5 ;
39784
39785   arg1 = (Dali::Animation *)jarg1;
39786   argp2 = (Dali::Actor *)jarg2;
39787   if (!argp2) {
39788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39789     return ;
39790   }
39791   arg2 = *argp2;
39792   argp3 = (Dali::Path *)jarg3;
39793   if (!argp3) {
39794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39795     return ;
39796   }
39797   arg3 = *argp3;
39798   arg4 = (Dali::Vector3 *)jarg4;
39799   if (!arg4) {
39800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39801     return ;
39802   }
39803   argp5 = (Dali::TimePeriod *)jarg5;
39804   if (!argp5) {
39805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39806     return ;
39807   }
39808   arg5 = *argp5;
39809   {
39810     try {
39811       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
39812     } catch (std::out_of_range& e) {
39813       {
39814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39815       };
39816     } catch (std::exception& e) {
39817       {
39818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39819       };
39820     } catch (...) {
39821       {
39822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39823       };
39824     }
39825   }
39826 }
39827
39828
39829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
39830   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39831   Dali::Actor arg2 ;
39832   Dali::Path arg3 ;
39833   Dali::Vector3 *arg4 = 0 ;
39834   Dali::AlphaFunction arg5 ;
39835   SwigValueWrapper< Dali::TimePeriod > arg6 ;
39836   Dali::Actor *argp2 ;
39837   Dali::Path *argp3 ;
39838   Dali::AlphaFunction *argp5 ;
39839   Dali::TimePeriod *argp6 ;
39840
39841   arg1 = (Dali::Animation *)jarg1;
39842   argp2 = (Dali::Actor *)jarg2;
39843   if (!argp2) {
39844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39845     return ;
39846   }
39847   arg2 = *argp2;
39848   argp3 = (Dali::Path *)jarg3;
39849   if (!argp3) {
39850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39851     return ;
39852   }
39853   arg3 = *argp3;
39854   arg4 = (Dali::Vector3 *)jarg4;
39855   if (!arg4) {
39856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39857     return ;
39858   }
39859   argp5 = (Dali::AlphaFunction *)jarg5;
39860   if (!argp5) {
39861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39862     return ;
39863   }
39864   arg5 = *argp5;
39865   argp6 = (Dali::TimePeriod *)jarg6;
39866   if (!argp6) {
39867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39868     return ;
39869   }
39870   arg6 = *argp6;
39871   {
39872     try {
39873       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
39874     } catch (std::out_of_range& e) {
39875       {
39876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39877       };
39878     } catch (std::exception& e) {
39879       {
39880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39881       };
39882     } catch (...) {
39883       {
39884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39885       };
39886     }
39887   }
39888 }
39889
39890
39891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
39892   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39893   Dali::Actor arg2 ;
39894   float arg3 ;
39895   Dali::Actor *argp2 ;
39896
39897   arg1 = (Dali::Animation *)jarg1;
39898   argp2 = (Dali::Actor *)jarg2;
39899   if (!argp2) {
39900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39901     return ;
39902   }
39903   arg2 = *argp2;
39904   arg3 = (float)jarg3;
39905   {
39906     try {
39907       (arg1)->Show(arg2,arg3);
39908     } catch (std::out_of_range& e) {
39909       {
39910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39911       };
39912     } catch (std::exception& e) {
39913       {
39914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39915       };
39916     } catch (...) {
39917       {
39918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39919       };
39920     }
39921   }
39922 }
39923
39924
39925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
39926   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39927   Dali::Actor arg2 ;
39928   float arg3 ;
39929   Dali::Actor *argp2 ;
39930
39931   arg1 = (Dali::Animation *)jarg1;
39932   argp2 = (Dali::Actor *)jarg2;
39933   if (!argp2) {
39934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39935     return ;
39936   }
39937   arg2 = *argp2;
39938   arg3 = (float)jarg3;
39939   {
39940     try {
39941       (arg1)->Hide(arg2,arg3);
39942     } catch (std::out_of_range& e) {
39943       {
39944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39945       };
39946     } catch (std::exception& e) {
39947       {
39948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39949       };
39950     } catch (...) {
39951       {
39952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39953       };
39954     }
39955   }
39956 }
39957
39958
39959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
39960   int jresult ;
39961   int result;
39962
39963   result = (int)Dali::LinearConstrainer::Property::VALUE;
39964   jresult = (int)result;
39965   return jresult;
39966 }
39967
39968
39969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
39970   int jresult ;
39971   int result;
39972
39973   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
39974   jresult = (int)result;
39975   return jresult;
39976 }
39977
39978
39979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
39980   void * jresult ;
39981   Dali::LinearConstrainer::Property *result = 0 ;
39982
39983   {
39984     try {
39985       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
39986     } catch (std::out_of_range& e) {
39987       {
39988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39989       };
39990     } catch (std::exception& e) {
39991       {
39992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39993       };
39994     } catch (...) {
39995       {
39996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39997       };
39998     }
39999   }
40000   jresult = (void *)result;
40001   return jresult;
40002 }
40003
40004
40005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40006   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40007
40008   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40009   {
40010     try {
40011       delete arg1;
40012     } catch (std::out_of_range& e) {
40013       {
40014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40015       };
40016     } catch (std::exception& e) {
40017       {
40018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40019       };
40020     } catch (...) {
40021       {
40022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40023       };
40024     }
40025   }
40026 }
40027
40028
40029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40030   void * jresult ;
40031   Dali::LinearConstrainer result;
40032
40033   {
40034     try {
40035       result = Dali::LinearConstrainer::New();
40036     } catch (std::out_of_range& e) {
40037       {
40038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40039       };
40040     } catch (std::exception& e) {
40041       {
40042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40043       };
40044     } catch (...) {
40045       {
40046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40047       };
40048     }
40049   }
40050   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40051   return jresult;
40052 }
40053
40054
40055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40056   void * jresult ;
40057   Dali::BaseHandle arg1 ;
40058   Dali::BaseHandle *argp1 ;
40059   Dali::LinearConstrainer result;
40060
40061   argp1 = (Dali::BaseHandle *)jarg1;
40062   if (!argp1) {
40063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40064     return 0;
40065   }
40066   arg1 = *argp1;
40067   {
40068     try {
40069       result = Dali::LinearConstrainer::DownCast(arg1);
40070     } catch (std::out_of_range& e) {
40071       {
40072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40073       };
40074     } catch (std::exception& e) {
40075       {
40076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40077       };
40078     } catch (...) {
40079       {
40080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40081       };
40082     }
40083   }
40084   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40085   return jresult;
40086 }
40087
40088
40089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40090   void * jresult ;
40091   Dali::LinearConstrainer *result = 0 ;
40092
40093   {
40094     try {
40095       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40096     } catch (std::out_of_range& e) {
40097       {
40098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40099       };
40100     } catch (std::exception& e) {
40101       {
40102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40103       };
40104     } catch (...) {
40105       {
40106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40107       };
40108     }
40109   }
40110   jresult = (void *)result;
40111   return jresult;
40112 }
40113
40114
40115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40116   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40117
40118   arg1 = (Dali::LinearConstrainer *)jarg1;
40119   {
40120     try {
40121       delete arg1;
40122     } catch (std::out_of_range& e) {
40123       {
40124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40125       };
40126     } catch (std::exception& e) {
40127       {
40128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40129       };
40130     } catch (...) {
40131       {
40132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40133       };
40134     }
40135   }
40136 }
40137
40138
40139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40140   void * jresult ;
40141   Dali::LinearConstrainer *arg1 = 0 ;
40142   Dali::LinearConstrainer *result = 0 ;
40143
40144   arg1 = (Dali::LinearConstrainer *)jarg1;
40145   if (!arg1) {
40146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40147     return 0;
40148   }
40149   {
40150     try {
40151       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40152     } catch (std::out_of_range& e) {
40153       {
40154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40155       };
40156     } catch (std::exception& e) {
40157       {
40158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40159       };
40160     } catch (...) {
40161       {
40162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40163       };
40164     }
40165   }
40166   jresult = (void *)result;
40167   return jresult;
40168 }
40169
40170
40171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40172   void * jresult ;
40173   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40174   Dali::LinearConstrainer *arg2 = 0 ;
40175   Dali::LinearConstrainer *result = 0 ;
40176
40177   arg1 = (Dali::LinearConstrainer *)jarg1;
40178   arg2 = (Dali::LinearConstrainer *)jarg2;
40179   if (!arg2) {
40180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40181     return 0;
40182   }
40183   {
40184     try {
40185       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40186     } catch (std::out_of_range& e) {
40187       {
40188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40189       };
40190     } catch (std::exception& e) {
40191       {
40192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40193       };
40194     } catch (...) {
40195       {
40196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40197       };
40198     }
40199   }
40200   jresult = (void *)result;
40201   return jresult;
40202 }
40203
40204
40205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40206   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40207   SwigValueWrapper< Dali::Property > arg2 ;
40208   SwigValueWrapper< Dali::Property > arg3 ;
40209   Dali::Vector2 *arg4 = 0 ;
40210   Dali::Vector2 *arg5 = 0 ;
40211   Dali::Property *argp2 ;
40212   Dali::Property *argp3 ;
40213
40214   arg1 = (Dali::LinearConstrainer *)jarg1;
40215   argp2 = (Dali::Property *)jarg2;
40216   if (!argp2) {
40217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40218     return ;
40219   }
40220   arg2 = *argp2;
40221   argp3 = (Dali::Property *)jarg3;
40222   if (!argp3) {
40223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40224     return ;
40225   }
40226   arg3 = *argp3;
40227   arg4 = (Dali::Vector2 *)jarg4;
40228   if (!arg4) {
40229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40230     return ;
40231   }
40232   arg5 = (Dali::Vector2 *)jarg5;
40233   if (!arg5) {
40234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40235     return ;
40236   }
40237   {
40238     try {
40239       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40240     } catch (std::out_of_range& e) {
40241       {
40242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40243       };
40244     } catch (std::exception& e) {
40245       {
40246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40247       };
40248     } catch (...) {
40249       {
40250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40251       };
40252     }
40253   }
40254 }
40255
40256
40257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40258   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40259   SwigValueWrapper< Dali::Property > arg2 ;
40260   SwigValueWrapper< Dali::Property > arg3 ;
40261   Dali::Vector2 *arg4 = 0 ;
40262   Dali::Property *argp2 ;
40263   Dali::Property *argp3 ;
40264
40265   arg1 = (Dali::LinearConstrainer *)jarg1;
40266   argp2 = (Dali::Property *)jarg2;
40267   if (!argp2) {
40268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40269     return ;
40270   }
40271   arg2 = *argp2;
40272   argp3 = (Dali::Property *)jarg3;
40273   if (!argp3) {
40274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40275     return ;
40276   }
40277   arg3 = *argp3;
40278   arg4 = (Dali::Vector2 *)jarg4;
40279   if (!arg4) {
40280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40281     return ;
40282   }
40283   {
40284     try {
40285       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40286     } catch (std::out_of_range& e) {
40287       {
40288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40289       };
40290     } catch (std::exception& e) {
40291       {
40292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40293       };
40294     } catch (...) {
40295       {
40296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40297       };
40298     }
40299   }
40300 }
40301
40302
40303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40304   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40305   Dali::Handle *arg2 = 0 ;
40306
40307   arg1 = (Dali::LinearConstrainer *)jarg1;
40308   arg2 = (Dali::Handle *)jarg2;
40309   if (!arg2) {
40310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40311     return ;
40312   }
40313   {
40314     try {
40315       (arg1)->Remove(*arg2);
40316     } catch (std::out_of_range& e) {
40317       {
40318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40319       };
40320     } catch (std::exception& e) {
40321       {
40322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40323       };
40324     } catch (...) {
40325       {
40326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40327       };
40328     }
40329   }
40330 }
40331
40332
40333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40334   int jresult ;
40335   int result;
40336
40337   result = (int)Dali::PathConstrainer::Property::FORWARD;
40338   jresult = (int)result;
40339   return jresult;
40340 }
40341
40342
40343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40344   int jresult ;
40345   int result;
40346
40347   result = (int)Dali::PathConstrainer::Property::POINTS;
40348   jresult = (int)result;
40349   return jresult;
40350 }
40351
40352
40353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40354   int jresult ;
40355   int result;
40356
40357   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40358   jresult = (int)result;
40359   return jresult;
40360 }
40361
40362
40363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40364   void * jresult ;
40365   Dali::PathConstrainer::Property *result = 0 ;
40366
40367   {
40368     try {
40369       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40370     } catch (std::out_of_range& e) {
40371       {
40372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40373       };
40374     } catch (std::exception& e) {
40375       {
40376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40377       };
40378     } catch (...) {
40379       {
40380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40381       };
40382     }
40383   }
40384   jresult = (void *)result;
40385   return jresult;
40386 }
40387
40388
40389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40390   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40391
40392   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40393   {
40394     try {
40395       delete arg1;
40396     } catch (std::out_of_range& e) {
40397       {
40398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40399       };
40400     } catch (std::exception& e) {
40401       {
40402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40403       };
40404     } catch (...) {
40405       {
40406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40407       };
40408     }
40409   }
40410 }
40411
40412
40413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40414   void * jresult ;
40415   Dali::PathConstrainer result;
40416
40417   {
40418     try {
40419       result = Dali::PathConstrainer::New();
40420     } catch (std::out_of_range& e) {
40421       {
40422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40423       };
40424     } catch (std::exception& e) {
40425       {
40426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40427       };
40428     } catch (...) {
40429       {
40430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40431       };
40432     }
40433   }
40434   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40435   return jresult;
40436 }
40437
40438
40439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40440   void * jresult ;
40441   Dali::BaseHandle arg1 ;
40442   Dali::BaseHandle *argp1 ;
40443   Dali::PathConstrainer result;
40444
40445   argp1 = (Dali::BaseHandle *)jarg1;
40446   if (!argp1) {
40447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40448     return 0;
40449   }
40450   arg1 = *argp1;
40451   {
40452     try {
40453       result = Dali::PathConstrainer::DownCast(arg1);
40454     } catch (std::out_of_range& e) {
40455       {
40456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40457       };
40458     } catch (std::exception& e) {
40459       {
40460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40461       };
40462     } catch (...) {
40463       {
40464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40465       };
40466     }
40467   }
40468   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40469   return jresult;
40470 }
40471
40472
40473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40474   void * jresult ;
40475   Dali::PathConstrainer *result = 0 ;
40476
40477   {
40478     try {
40479       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
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 = (void *)result;
40495   return jresult;
40496 }
40497
40498
40499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40500   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40501
40502   arg1 = (Dali::PathConstrainer *)jarg1;
40503   {
40504     try {
40505       delete arg1;
40506     } catch (std::out_of_range& e) {
40507       {
40508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40509       };
40510     } catch (std::exception& e) {
40511       {
40512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40513       };
40514     } catch (...) {
40515       {
40516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40517       };
40518     }
40519   }
40520 }
40521
40522
40523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
40524   void * jresult ;
40525   Dali::PathConstrainer *arg1 = 0 ;
40526   Dali::PathConstrainer *result = 0 ;
40527
40528   arg1 = (Dali::PathConstrainer *)jarg1;
40529   if (!arg1) {
40530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40531     return 0;
40532   }
40533   {
40534     try {
40535       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
40536     } catch (std::out_of_range& e) {
40537       {
40538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40539       };
40540     } catch (std::exception& e) {
40541       {
40542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40543       };
40544     } catch (...) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40547       };
40548     }
40549   }
40550   jresult = (void *)result;
40551   return jresult;
40552 }
40553
40554
40555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
40556   void * jresult ;
40557   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40558   Dali::PathConstrainer *arg2 = 0 ;
40559   Dali::PathConstrainer *result = 0 ;
40560
40561   arg1 = (Dali::PathConstrainer *)jarg1;
40562   arg2 = (Dali::PathConstrainer *)jarg2;
40563   if (!arg2) {
40564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40565     return 0;
40566   }
40567   {
40568     try {
40569       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
40570     } catch (std::out_of_range& e) {
40571       {
40572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40573       };
40574     } catch (std::exception& e) {
40575       {
40576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40577       };
40578     } catch (...) {
40579       {
40580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40581       };
40582     }
40583   }
40584   jresult = (void *)result;
40585   return jresult;
40586 }
40587
40588
40589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40590   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40591   SwigValueWrapper< Dali::Property > arg2 ;
40592   SwigValueWrapper< Dali::Property > arg3 ;
40593   Dali::Vector2 *arg4 = 0 ;
40594   Dali::Vector2 *arg5 = 0 ;
40595   Dali::Property *argp2 ;
40596   Dali::Property *argp3 ;
40597
40598   arg1 = (Dali::PathConstrainer *)jarg1;
40599   argp2 = (Dali::Property *)jarg2;
40600   if (!argp2) {
40601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40602     return ;
40603   }
40604   arg2 = *argp2;
40605   argp3 = (Dali::Property *)jarg3;
40606   if (!argp3) {
40607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40608     return ;
40609   }
40610   arg3 = *argp3;
40611   arg4 = (Dali::Vector2 *)jarg4;
40612   if (!arg4) {
40613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40614     return ;
40615   }
40616   arg5 = (Dali::Vector2 *)jarg5;
40617   if (!arg5) {
40618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40619     return ;
40620   }
40621   {
40622     try {
40623       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40624     } catch (std::out_of_range& e) {
40625       {
40626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40627       };
40628     } catch (std::exception& e) {
40629       {
40630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40631       };
40632     } catch (...) {
40633       {
40634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40635       };
40636     }
40637   }
40638 }
40639
40640
40641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40642   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40643   SwigValueWrapper< Dali::Property > arg2 ;
40644   SwigValueWrapper< Dali::Property > arg3 ;
40645   Dali::Vector2 *arg4 = 0 ;
40646   Dali::Property *argp2 ;
40647   Dali::Property *argp3 ;
40648
40649   arg1 = (Dali::PathConstrainer *)jarg1;
40650   argp2 = (Dali::Property *)jarg2;
40651   if (!argp2) {
40652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40653     return ;
40654   }
40655   arg2 = *argp2;
40656   argp3 = (Dali::Property *)jarg3;
40657   if (!argp3) {
40658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40659     return ;
40660   }
40661   arg3 = *argp3;
40662   arg4 = (Dali::Vector2 *)jarg4;
40663   if (!arg4) {
40664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40665     return ;
40666   }
40667   {
40668     try {
40669       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40670     } catch (std::out_of_range& e) {
40671       {
40672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40673       };
40674     } catch (std::exception& e) {
40675       {
40676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40677       };
40678     } catch (...) {
40679       {
40680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40681       };
40682     }
40683   }
40684 }
40685
40686
40687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
40688   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40689   Dali::Handle *arg2 = 0 ;
40690
40691   arg1 = (Dali::PathConstrainer *)jarg1;
40692   arg2 = (Dali::Handle *)jarg2;
40693   if (!arg2) {
40694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40695     return ;
40696   }
40697   {
40698     try {
40699       (arg1)->Remove(*arg2);
40700     } catch (std::out_of_range& e) {
40701       {
40702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40703       };
40704     } catch (std::exception& e) {
40705       {
40706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40707       };
40708     } catch (...) {
40709       {
40710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40711       };
40712     }
40713   }
40714 }
40715
40716
40717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
40718   int jresult ;
40719   Dali::FittingMode::Type result;
40720
40721   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
40722   jresult = (int)result;
40723   return jresult;
40724 }
40725
40726
40727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
40728   int jresult ;
40729   Dali::SamplingMode::Type result;
40730
40731   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
40732   jresult = (int)result;
40733   return jresult;
40734 }
40735
40736
40737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
40738   void * jresult ;
40739   Dali::BufferImage *result = 0 ;
40740
40741   {
40742     try {
40743       result = (Dali::BufferImage *)new Dali::BufferImage();
40744     } catch (std::out_of_range& e) {
40745       {
40746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40747       };
40748     } catch (std::exception& e) {
40749       {
40750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40751       };
40752     } catch (...) {
40753       {
40754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40755       };
40756     }
40757   }
40758   jresult = (void *)result;
40759   return jresult;
40760 }
40761
40762
40763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
40764   void * jresult ;
40765   unsigned int arg1 ;
40766   unsigned int arg2 ;
40767   Dali::Pixel::Format arg3 ;
40768   Dali::BufferImage result;
40769
40770   arg1 = (unsigned int)jarg1;
40771   arg2 = (unsigned int)jarg2;
40772   arg3 = (Dali::Pixel::Format)jarg3;
40773   {
40774     try {
40775       result = Dali::BufferImage::New(arg1,arg2,arg3);
40776     } catch (std::out_of_range& e) {
40777       {
40778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40779       };
40780     } catch (std::exception& e) {
40781       {
40782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40783       };
40784     } catch (...) {
40785       {
40786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40787       };
40788     }
40789   }
40790   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40791   return jresult;
40792 }
40793
40794
40795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
40796   void * jresult ;
40797   unsigned int arg1 ;
40798   unsigned int arg2 ;
40799   Dali::BufferImage result;
40800
40801   arg1 = (unsigned int)jarg1;
40802   arg2 = (unsigned int)jarg2;
40803   {
40804     try {
40805       result = Dali::BufferImage::New(arg1,arg2);
40806     } catch (std::out_of_range& e) {
40807       {
40808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40809       };
40810     } catch (std::exception& e) {
40811       {
40812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40813       };
40814     } catch (...) {
40815       {
40816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40817       };
40818     }
40819   }
40820   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40821   return jresult;
40822 }
40823
40824
40825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
40826   void * jresult ;
40827   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
40828   unsigned int arg2 ;
40829   unsigned int arg3 ;
40830   Dali::Pixel::Format arg4 ;
40831   unsigned int arg5 ;
40832   Dali::BufferImage result;
40833
40834   arg1 = jarg1;
40835   arg2 = (unsigned int)jarg2;
40836   arg3 = (unsigned int)jarg3;
40837   arg4 = (Dali::Pixel::Format)jarg4;
40838   arg5 = (unsigned int)jarg5;
40839   {
40840     try {
40841       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
40842     } catch (std::out_of_range& e) {
40843       {
40844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40845       };
40846     } catch (std::exception& e) {
40847       {
40848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40849       };
40850     } catch (...) {
40851       {
40852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40853       };
40854     }
40855   }
40856   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40857
40858
40859   return jresult;
40860 }
40861
40862
40863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
40864   void * jresult ;
40865   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
40866   unsigned int arg2 ;
40867   unsigned int arg3 ;
40868   Dali::Pixel::Format arg4 ;
40869   Dali::BufferImage result;
40870
40871   arg1 = jarg1;
40872   arg2 = (unsigned int)jarg2;
40873   arg3 = (unsigned int)jarg3;
40874   arg4 = (Dali::Pixel::Format)jarg4;
40875   {
40876     try {
40877       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
40878     } catch (std::out_of_range& e) {
40879       {
40880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40881       };
40882     } catch (std::exception& e) {
40883       {
40884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40885       };
40886     } catch (...) {
40887       {
40888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40889       };
40890     }
40891   }
40892   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40893
40894
40895   return jresult;
40896 }
40897
40898
40899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
40900   void * jresult ;
40901   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
40902   unsigned int arg2 ;
40903   unsigned int arg3 ;
40904   Dali::BufferImage result;
40905
40906   arg1 = jarg1;
40907   arg2 = (unsigned int)jarg2;
40908   arg3 = (unsigned int)jarg3;
40909   {
40910     try {
40911       result = Dali::BufferImage::New(arg1,arg2,arg3);
40912     } catch (std::out_of_range& e) {
40913       {
40914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40915       };
40916     } catch (std::exception& e) {
40917       {
40918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40919       };
40920     } catch (...) {
40921       {
40922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40923       };
40924     }
40925   }
40926   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40927
40928
40929   return jresult;
40930 }
40931
40932
40933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
40934   void * jresult ;
40935   Dali::BaseHandle arg1 ;
40936   Dali::BaseHandle *argp1 ;
40937   Dali::BufferImage result;
40938
40939   argp1 = (Dali::BaseHandle *)jarg1;
40940   if (!argp1) {
40941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40942     return 0;
40943   }
40944   arg1 = *argp1;
40945   {
40946     try {
40947       result = Dali::BufferImage::DownCast(arg1);
40948     } catch (std::out_of_range& e) {
40949       {
40950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40951       };
40952     } catch (std::exception& e) {
40953       {
40954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40955       };
40956     } catch (...) {
40957       {
40958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40959       };
40960     }
40961   }
40962   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40963   return jresult;
40964 }
40965
40966
40967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
40968   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
40969
40970   arg1 = (Dali::BufferImage *)jarg1;
40971   {
40972     try {
40973       delete arg1;
40974     } catch (std::out_of_range& e) {
40975       {
40976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40977       };
40978     } catch (std::exception& e) {
40979       {
40980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40981       };
40982     } catch (...) {
40983       {
40984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40985       };
40986     }
40987   }
40988 }
40989
40990
40991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
40992   void * jresult ;
40993   Dali::BufferImage *arg1 = 0 ;
40994   Dali::BufferImage *result = 0 ;
40995
40996   arg1 = (Dali::BufferImage *)jarg1;
40997   if (!arg1) {
40998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
40999     return 0;
41000   }
41001   {
41002     try {
41003       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41004     } catch (std::out_of_range& e) {
41005       {
41006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41007       };
41008     } catch (std::exception& e) {
41009       {
41010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41011       };
41012     } catch (...) {
41013       {
41014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41015       };
41016     }
41017   }
41018   jresult = (void *)result;
41019   return jresult;
41020 }
41021
41022
41023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41024   void * jresult ;
41025   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41026   Dali::BufferImage *arg2 = 0 ;
41027   Dali::BufferImage *result = 0 ;
41028
41029   arg1 = (Dali::BufferImage *)jarg1;
41030   arg2 = (Dali::BufferImage *)jarg2;
41031   if (!arg2) {
41032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41033     return 0;
41034   }
41035   {
41036     try {
41037       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41038     } catch (std::out_of_range& e) {
41039       {
41040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41041       };
41042     } catch (std::exception& e) {
41043       {
41044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41045       };
41046     } catch (...) {
41047       {
41048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41049       };
41050     }
41051   }
41052   jresult = (void *)result;
41053   return jresult;
41054 }
41055
41056
41057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41058   void * jresult ;
41059   Dali::BufferImage result;
41060
41061   {
41062     try {
41063       result = Dali::BufferImage::WHITE();
41064     } catch (std::out_of_range& e) {
41065       {
41066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41067       };
41068     } catch (std::exception& e) {
41069       {
41070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41071       };
41072     } catch (...) {
41073       {
41074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41075       };
41076     }
41077   }
41078   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41079   return jresult;
41080 }
41081
41082
41083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41084   void * jresult ;
41085   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41086   Dali::PixelBuffer *result = 0 ;
41087
41088   arg1 = (Dali::BufferImage *)jarg1;
41089   {
41090     try {
41091       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41092     } catch (std::out_of_range& e) {
41093       {
41094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41095       };
41096     } catch (std::exception& e) {
41097       {
41098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41099       };
41100     } catch (...) {
41101       {
41102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41103       };
41104     }
41105   }
41106   jresult = (void *)result;
41107   return jresult;
41108 }
41109
41110
41111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41112   unsigned int jresult ;
41113   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41114   unsigned int result;
41115
41116   arg1 = (Dali::BufferImage *)jarg1;
41117   {
41118     try {
41119       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41120     } catch (std::out_of_range& e) {
41121       {
41122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41123       };
41124     } catch (std::exception& e) {
41125       {
41126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41127       };
41128     } catch (...) {
41129       {
41130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41131       };
41132     }
41133   }
41134   jresult = result;
41135   return jresult;
41136 }
41137
41138
41139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41140   unsigned int jresult ;
41141   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41142   unsigned int result;
41143
41144   arg1 = (Dali::BufferImage *)jarg1;
41145   {
41146     try {
41147       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41148     } catch (std::out_of_range& e) {
41149       {
41150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41151       };
41152     } catch (std::exception& e) {
41153       {
41154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41155       };
41156     } catch (...) {
41157       {
41158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41159       };
41160     }
41161   }
41162   jresult = result;
41163   return jresult;
41164 }
41165
41166
41167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41168   int jresult ;
41169   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41170   Dali::Pixel::Format result;
41171
41172   arg1 = (Dali::BufferImage *)jarg1;
41173   {
41174     try {
41175       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41176     } catch (std::out_of_range& e) {
41177       {
41178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41179       };
41180     } catch (std::exception& e) {
41181       {
41182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41183       };
41184     } catch (...) {
41185       {
41186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41187       };
41188     }
41189   }
41190   jresult = (int)result;
41191   return jresult;
41192 }
41193
41194
41195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41196   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41197
41198   arg1 = (Dali::BufferImage *)jarg1;
41199   {
41200     try {
41201       (arg1)->Update();
41202     } catch (std::out_of_range& e) {
41203       {
41204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41205       };
41206     } catch (std::exception& e) {
41207       {
41208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41209       };
41210     } catch (...) {
41211       {
41212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41213       };
41214     }
41215   }
41216 }
41217
41218
41219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41220   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41221   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41222   Dali::RectArea *argp2 ;
41223
41224   arg1 = (Dali::BufferImage *)jarg1;
41225   argp2 = (Dali::RectArea *)jarg2;
41226   if (!argp2) {
41227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41228     return ;
41229   }
41230   arg2 = *argp2;
41231   {
41232     try {
41233       (arg1)->Update(arg2);
41234     } catch (std::out_of_range& e) {
41235       {
41236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41237       };
41238     } catch (std::exception& e) {
41239       {
41240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41241       };
41242     } catch (...) {
41243       {
41244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41245       };
41246     }
41247   }
41248 }
41249
41250
41251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41252   unsigned int jresult ;
41253   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41254   bool result;
41255
41256   arg1 = (Dali::BufferImage *)jarg1;
41257   {
41258     try {
41259       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41260     } catch (std::out_of_range& e) {
41261       {
41262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41263       };
41264     } catch (std::exception& e) {
41265       {
41266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41267       };
41268     } catch (...) {
41269       {
41270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41271       };
41272     }
41273   }
41274   jresult = result;
41275   return jresult;
41276 }
41277
41278
41279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41280   void * jresult ;
41281   Dali::EncodedBufferImage *result = 0 ;
41282
41283   {
41284     try {
41285       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41286     } catch (std::out_of_range& e) {
41287       {
41288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41289       };
41290     } catch (std::exception& e) {
41291       {
41292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41293       };
41294     } catch (...) {
41295       {
41296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41297       };
41298     }
41299   }
41300   jresult = (void *)result;
41301   return jresult;
41302 }
41303
41304
41305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41306   void * jresult ;
41307   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41308   std::size_t arg2 ;
41309   Dali::EncodedBufferImage result;
41310
41311   arg1 = (uint8_t *)jarg1;
41312   arg2 = (std::size_t)jarg2;
41313   {
41314     try {
41315       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41316     } catch (std::out_of_range& e) {
41317       {
41318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41319       };
41320     } catch (std::exception& e) {
41321       {
41322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41323       };
41324     } catch (...) {
41325       {
41326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41327       };
41328     }
41329   }
41330   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41331   return jresult;
41332 }
41333
41334
41335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41336   void * jresult ;
41337   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41338   std::size_t arg2 ;
41339   Dali::ImageDimensions arg3 ;
41340   Dali::FittingMode::Type arg4 ;
41341   Dali::SamplingMode::Type arg5 ;
41342   bool arg6 ;
41343   Dali::ImageDimensions *argp3 ;
41344   Dali::EncodedBufferImage result;
41345
41346   arg1 = (uint8_t *)jarg1;
41347   arg2 = (std::size_t)jarg2;
41348   argp3 = (Dali::ImageDimensions *)jarg3;
41349   if (!argp3) {
41350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41351     return 0;
41352   }
41353   arg3 = *argp3;
41354   arg4 = (Dali::FittingMode::Type)jarg4;
41355   arg5 = (Dali::SamplingMode::Type)jarg5;
41356   arg6 = jarg6 ? true : false;
41357   {
41358     try {
41359       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41360     } catch (std::out_of_range& e) {
41361       {
41362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41363       };
41364     } catch (std::exception& e) {
41365       {
41366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41367       };
41368     } catch (...) {
41369       {
41370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41371       };
41372     }
41373   }
41374   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41375   return jresult;
41376 }
41377
41378
41379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41380   void * jresult ;
41381   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41382   std::size_t arg2 ;
41383   Dali::ImageDimensions arg3 ;
41384   Dali::FittingMode::Type arg4 ;
41385   Dali::SamplingMode::Type arg5 ;
41386   Dali::ImageDimensions *argp3 ;
41387   Dali::EncodedBufferImage result;
41388
41389   arg1 = (uint8_t *)jarg1;
41390   arg2 = (std::size_t)jarg2;
41391   argp3 = (Dali::ImageDimensions *)jarg3;
41392   if (!argp3) {
41393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41394     return 0;
41395   }
41396   arg3 = *argp3;
41397   arg4 = (Dali::FittingMode::Type)jarg4;
41398   arg5 = (Dali::SamplingMode::Type)jarg5;
41399   {
41400     try {
41401       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41402     } catch (std::out_of_range& e) {
41403       {
41404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41405       };
41406     } catch (std::exception& e) {
41407       {
41408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41409       };
41410     } catch (...) {
41411       {
41412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41413       };
41414     }
41415   }
41416   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41417   return jresult;
41418 }
41419
41420
41421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41422   void * jresult ;
41423   Dali::BaseHandle arg1 ;
41424   Dali::BaseHandle *argp1 ;
41425   Dali::EncodedBufferImage result;
41426
41427   argp1 = (Dali::BaseHandle *)jarg1;
41428   if (!argp1) {
41429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41430     return 0;
41431   }
41432   arg1 = *argp1;
41433   {
41434     try {
41435       result = Dali::EncodedBufferImage::DownCast(arg1);
41436     } catch (std::out_of_range& e) {
41437       {
41438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41439       };
41440     } catch (std::exception& e) {
41441       {
41442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41443       };
41444     } catch (...) {
41445       {
41446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41447       };
41448     }
41449   }
41450   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41451   return jresult;
41452 }
41453
41454
41455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41456   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41457
41458   arg1 = (Dali::EncodedBufferImage *)jarg1;
41459   {
41460     try {
41461       delete arg1;
41462     } catch (std::out_of_range& e) {
41463       {
41464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41465       };
41466     } catch (std::exception& e) {
41467       {
41468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41469       };
41470     } catch (...) {
41471       {
41472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41473       };
41474     }
41475   }
41476 }
41477
41478
41479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41480   void * jresult ;
41481   Dali::EncodedBufferImage *arg1 = 0 ;
41482   Dali::EncodedBufferImage *result = 0 ;
41483
41484   arg1 = (Dali::EncodedBufferImage *)jarg1;
41485   if (!arg1) {
41486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41487     return 0;
41488   }
41489   {
41490     try {
41491       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41492     } catch (std::out_of_range& e) {
41493       {
41494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41495       };
41496     } catch (std::exception& e) {
41497       {
41498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41499       };
41500     } catch (...) {
41501       {
41502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41503       };
41504     }
41505   }
41506   jresult = (void *)result;
41507   return jresult;
41508 }
41509
41510
41511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41512   void * jresult ;
41513   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41514   Dali::EncodedBufferImage *arg2 = 0 ;
41515   Dali::EncodedBufferImage *result = 0 ;
41516
41517   arg1 = (Dali::EncodedBufferImage *)jarg1;
41518   arg2 = (Dali::EncodedBufferImage *)jarg2;
41519   if (!arg2) {
41520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41521     return 0;
41522   }
41523   {
41524     try {
41525       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
41526     } catch (std::out_of_range& e) {
41527       {
41528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41529       };
41530     } catch (std::exception& e) {
41531       {
41532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41533       };
41534     } catch (...) {
41535       {
41536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41537       };
41538     }
41539   }
41540   jresult = (void *)result;
41541   return jresult;
41542 }
41543
41544
41545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
41546   void * jresult ;
41547   Dali::NativeImage *result = 0 ;
41548
41549   {
41550     try {
41551       result = (Dali::NativeImage *)new Dali::NativeImage();
41552     } catch (std::out_of_range& e) {
41553       {
41554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41555       };
41556     } catch (std::exception& e) {
41557       {
41558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41559       };
41560     } catch (...) {
41561       {
41562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41563       };
41564     }
41565   }
41566   jresult = (void *)result;
41567   return jresult;
41568 }
41569
41570
41571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
41572   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41573
41574   arg1 = (Dali::NativeImage *)jarg1;
41575   {
41576     try {
41577       delete arg1;
41578     } catch (std::out_of_range& e) {
41579       {
41580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41581       };
41582     } catch (std::exception& e) {
41583       {
41584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41585       };
41586     } catch (...) {
41587       {
41588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41589       };
41590     }
41591   }
41592 }
41593
41594
41595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
41596   void * jresult ;
41597   Dali::NativeImage *arg1 = 0 ;
41598   Dali::NativeImage *result = 0 ;
41599
41600   arg1 = (Dali::NativeImage *)jarg1;
41601   if (!arg1) {
41602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41603     return 0;
41604   }
41605   {
41606     try {
41607       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
41608     } catch (std::out_of_range& e) {
41609       {
41610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41611       };
41612     } catch (std::exception& e) {
41613       {
41614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41615       };
41616     } catch (...) {
41617       {
41618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41619       };
41620     }
41621   }
41622   jresult = (void *)result;
41623   return jresult;
41624 }
41625
41626
41627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
41628   void * jresult ;
41629   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41630   Dali::NativeImage *arg2 = 0 ;
41631   Dali::NativeImage *result = 0 ;
41632
41633   arg1 = (Dali::NativeImage *)jarg1;
41634   arg2 = (Dali::NativeImage *)jarg2;
41635   if (!arg2) {
41636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41637     return 0;
41638   }
41639   {
41640     try {
41641       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
41642     } catch (std::out_of_range& e) {
41643       {
41644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41645       };
41646     } catch (std::exception& e) {
41647       {
41648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41649       };
41650     } catch (...) {
41651       {
41652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41653       };
41654     }
41655   }
41656   jresult = (void *)result;
41657   return jresult;
41658 }
41659
41660
41661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
41662   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41663
41664   arg1 = (Dali::NativeImage *)jarg1;
41665   {
41666     try {
41667       (arg1)->CreateGlTexture();
41668     } catch (std::out_of_range& e) {
41669       {
41670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41671       };
41672     } catch (std::exception& e) {
41673       {
41674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41675       };
41676     } catch (...) {
41677       {
41678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41679       };
41680     }
41681   }
41682 }
41683
41684
41685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
41686   void * jresult ;
41687   NativeImageInterface *arg1 = 0 ;
41688   Dali::NativeImage result;
41689
41690   arg1 = (NativeImageInterface *)jarg1;
41691   if (!arg1) {
41692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
41693     return 0;
41694   }
41695   {
41696     try {
41697       result = Dali::NativeImage::New(*arg1);
41698     } catch (std::out_of_range& e) {
41699       {
41700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41701       };
41702     } catch (std::exception& e) {
41703       {
41704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41705       };
41706     } catch (...) {
41707       {
41708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41709       };
41710     }
41711   }
41712   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
41713   return jresult;
41714 }
41715
41716
41717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
41718   void * jresult ;
41719   Dali::BaseHandle arg1 ;
41720   Dali::BaseHandle *argp1 ;
41721   Dali::NativeImage result;
41722
41723   argp1 = (Dali::BaseHandle *)jarg1;
41724   if (!argp1) {
41725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41726     return 0;
41727   }
41728   arg1 = *argp1;
41729   {
41730     try {
41731       result = Dali::NativeImage::DownCast(arg1);
41732     } catch (std::out_of_range& e) {
41733       {
41734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41735       };
41736     } catch (std::exception& e) {
41737       {
41738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41739       };
41740     } catch (...) {
41741       {
41742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41743       };
41744     }
41745   }
41746   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
41747   return jresult;
41748 }
41749
41750
41751 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
41752   char * jresult ;
41753   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41754   char *result = 0 ;
41755
41756   arg1 = (Dali::NativeImage *)jarg1;
41757   {
41758     try {
41759       result = (char *)(arg1)->GetCustomFragmentPreFix();
41760     } catch (std::out_of_range& e) {
41761       {
41762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41763       };
41764     } catch (std::exception& e) {
41765       {
41766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41767       };
41768     } catch (...) {
41769       {
41770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41771       };
41772     }
41773   }
41774   jresult = SWIG_csharp_string_callback((const char *)result);
41775   return jresult;
41776 }
41777
41778
41779 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
41780   char * jresult ;
41781   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41782   char *result = 0 ;
41783
41784   arg1 = (Dali::NativeImage *)jarg1;
41785   {
41786     try {
41787       result = (char *)(arg1)->GetCustomSamplerTypename();
41788     } catch (std::out_of_range& e) {
41789       {
41790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41791       };
41792     } catch (std::exception& e) {
41793       {
41794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41795       };
41796     } catch (...) {
41797       {
41798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41799       };
41800     }
41801   }
41802   jresult = SWIG_csharp_string_callback((const char *)result);
41803   return jresult;
41804 }
41805
41806
41807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
41808   unsigned int jresult ;
41809   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41810   bool result;
41811
41812   arg1 = (Dali::NativeImageInterface *)jarg1;
41813   {
41814     try {
41815       result = (bool)(arg1)->GlExtensionCreate();
41816     } catch (std::out_of_range& e) {
41817       {
41818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41819       };
41820     } catch (std::exception& e) {
41821       {
41822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41823       };
41824     } catch (...) {
41825       {
41826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41827       };
41828     }
41829   }
41830   jresult = result;
41831   return jresult;
41832 }
41833
41834
41835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
41836   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41837
41838   arg1 = (Dali::NativeImageInterface *)jarg1;
41839   {
41840     try {
41841       (arg1)->GlExtensionDestroy();
41842     } catch (std::out_of_range& e) {
41843       {
41844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41845       };
41846     } catch (std::exception& e) {
41847       {
41848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41849       };
41850     } catch (...) {
41851       {
41852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41853       };
41854     }
41855   }
41856 }
41857
41858
41859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
41860   unsigned int jresult ;
41861   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41862   unsigned int result;
41863
41864   arg1 = (Dali::NativeImageInterface *)jarg1;
41865   {
41866     try {
41867       result = (unsigned int)(arg1)->TargetTexture();
41868     } catch (std::out_of_range& e) {
41869       {
41870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41871       };
41872     } catch (std::exception& e) {
41873       {
41874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41875       };
41876     } catch (...) {
41877       {
41878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41879       };
41880     }
41881   }
41882   jresult = result;
41883   return jresult;
41884 }
41885
41886
41887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
41888   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41889
41890   arg1 = (Dali::NativeImageInterface *)jarg1;
41891   {
41892     try {
41893       (arg1)->PrepareTexture();
41894     } catch (std::out_of_range& e) {
41895       {
41896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41897       };
41898     } catch (std::exception& e) {
41899       {
41900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41901       };
41902     } catch (...) {
41903       {
41904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41905       };
41906     }
41907   }
41908 }
41909
41910
41911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
41912   unsigned int jresult ;
41913   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41914   unsigned int result;
41915
41916   arg1 = (Dali::NativeImageInterface *)jarg1;
41917   {
41918     try {
41919       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
41920     } catch (std::out_of_range& e) {
41921       {
41922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41923       };
41924     } catch (std::exception& e) {
41925       {
41926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41927       };
41928     } catch (...) {
41929       {
41930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41931       };
41932     }
41933   }
41934   jresult = result;
41935   return jresult;
41936 }
41937
41938
41939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
41940   unsigned int jresult ;
41941   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41942   unsigned int result;
41943
41944   arg1 = (Dali::NativeImageInterface *)jarg1;
41945   {
41946     try {
41947       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
41948     } catch (std::out_of_range& e) {
41949       {
41950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41951       };
41952     } catch (std::exception& e) {
41953       {
41954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41955       };
41956     } catch (...) {
41957       {
41958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41959       };
41960     }
41961   }
41962   jresult = result;
41963   return jresult;
41964 }
41965
41966
41967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
41968   unsigned int jresult ;
41969   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41970   bool result;
41971
41972   arg1 = (Dali::NativeImageInterface *)jarg1;
41973   {
41974     try {
41975       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
41976     } catch (std::out_of_range& e) {
41977       {
41978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41979       };
41980     } catch (std::exception& e) {
41981       {
41982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41983       };
41984     } catch (...) {
41985       {
41986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41987       };
41988     }
41989   }
41990   jresult = result;
41991   return jresult;
41992 }
41993
41994
41995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
41996   void * jresult ;
41997   std::string *arg1 = 0 ;
41998   Dali::ImageDimensions result;
41999
42000   if (!jarg1) {
42001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42002     return 0;
42003   }
42004   std::string arg1_str(jarg1);
42005   arg1 = &arg1_str;
42006   {
42007     try {
42008       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42009     } catch (std::out_of_range& e) {
42010       {
42011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42012       };
42013     } catch (std::exception& e) {
42014       {
42015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42016       };
42017     } catch (...) {
42018       {
42019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42020       };
42021     }
42022   }
42023   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42024
42025   //argout typemap for const std::string&
42026
42027   return jresult;
42028 }
42029
42030
42031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42032   void * jresult ;
42033   Dali::ResourceImage *result = 0 ;
42034
42035   {
42036     try {
42037       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42038     } catch (std::out_of_range& e) {
42039       {
42040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42041       };
42042     } catch (std::exception& e) {
42043       {
42044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42045       };
42046     } catch (...) {
42047       {
42048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42049       };
42050     }
42051   }
42052   jresult = (void *)result;
42053   return jresult;
42054 }
42055
42056
42057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42058   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42059
42060   arg1 = (Dali::ResourceImage *)jarg1;
42061   {
42062     try {
42063       delete arg1;
42064     } catch (std::out_of_range& e) {
42065       {
42066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42067       };
42068     } catch (std::exception& e) {
42069       {
42070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42071       };
42072     } catch (...) {
42073       {
42074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42075       };
42076     }
42077   }
42078 }
42079
42080
42081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42082   void * jresult ;
42083   Dali::ResourceImage *arg1 = 0 ;
42084   Dali::ResourceImage *result = 0 ;
42085
42086   arg1 = (Dali::ResourceImage *)jarg1;
42087   if (!arg1) {
42088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42089     return 0;
42090   }
42091   {
42092     try {
42093       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42094     } catch (std::out_of_range& e) {
42095       {
42096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42097       };
42098     } catch (std::exception& e) {
42099       {
42100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42101       };
42102     } catch (...) {
42103       {
42104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42105       };
42106     }
42107   }
42108   jresult = (void *)result;
42109   return jresult;
42110 }
42111
42112
42113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42114   void * jresult ;
42115   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42116   Dali::ResourceImage *arg2 = 0 ;
42117   Dali::ResourceImage *result = 0 ;
42118
42119   arg1 = (Dali::ResourceImage *)jarg1;
42120   arg2 = (Dali::ResourceImage *)jarg2;
42121   if (!arg2) {
42122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42123     return 0;
42124   }
42125   {
42126     try {
42127       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42128     } catch (std::out_of_range& e) {
42129       {
42130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42131       };
42132     } catch (std::exception& e) {
42133       {
42134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42135       };
42136     } catch (...) {
42137       {
42138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42139       };
42140     }
42141   }
42142   jresult = (void *)result;
42143   return jresult;
42144 }
42145
42146
42147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42148   void * jresult ;
42149   std::string *arg1 = 0 ;
42150   bool arg2 ;
42151   Dali::ResourceImage result;
42152
42153   if (!jarg1) {
42154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42155     return 0;
42156   }
42157   std::string arg1_str(jarg1);
42158   arg1 = &arg1_str;
42159   arg2 = jarg2 ? true : false;
42160   {
42161     try {
42162       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42163     } catch (std::out_of_range& e) {
42164       {
42165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42166       };
42167     } catch (std::exception& e) {
42168       {
42169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42170       };
42171     } catch (...) {
42172       {
42173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42174       };
42175     }
42176   }
42177   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42178
42179   //argout typemap for const std::string&
42180
42181   return jresult;
42182 }
42183
42184
42185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42186   void * jresult ;
42187   std::string *arg1 = 0 ;
42188   Dali::ResourceImage result;
42189
42190   if (!jarg1) {
42191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42192     return 0;
42193   }
42194   std::string arg1_str(jarg1);
42195   arg1 = &arg1_str;
42196   {
42197     try {
42198       result = Dali::ResourceImage::New((std::string const &)*arg1);
42199     } catch (std::out_of_range& e) {
42200       {
42201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42202       };
42203     } catch (std::exception& e) {
42204       {
42205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42206       };
42207     } catch (...) {
42208       {
42209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42210       };
42211     }
42212   }
42213   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42214
42215   //argout typemap for const std::string&
42216
42217   return jresult;
42218 }
42219
42220
42221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42222   void * jresult ;
42223   std::string *arg1 = 0 ;
42224   Dali::ImageDimensions arg2 ;
42225   Dali::FittingMode::Type arg3 ;
42226   Dali::SamplingMode::Type arg4 ;
42227   bool arg5 ;
42228   Dali::ImageDimensions *argp2 ;
42229   Dali::ResourceImage result;
42230
42231   if (!jarg1) {
42232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42233     return 0;
42234   }
42235   std::string arg1_str(jarg1);
42236   arg1 = &arg1_str;
42237   argp2 = (Dali::ImageDimensions *)jarg2;
42238   if (!argp2) {
42239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42240     return 0;
42241   }
42242   arg2 = *argp2;
42243   arg3 = (Dali::FittingMode::Type)jarg3;
42244   arg4 = (Dali::SamplingMode::Type)jarg4;
42245   arg5 = jarg5 ? true : false;
42246   {
42247     try {
42248       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42249     } catch (std::out_of_range& e) {
42250       {
42251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42252       };
42253     } catch (std::exception& e) {
42254       {
42255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42256       };
42257     } catch (...) {
42258       {
42259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42260       };
42261     }
42262   }
42263   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42264
42265   //argout typemap for const std::string&
42266
42267   return jresult;
42268 }
42269
42270
42271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42272   void * jresult ;
42273   std::string *arg1 = 0 ;
42274   Dali::ImageDimensions arg2 ;
42275   Dali::FittingMode::Type arg3 ;
42276   Dali::SamplingMode::Type arg4 ;
42277   Dali::ImageDimensions *argp2 ;
42278   Dali::ResourceImage result;
42279
42280   if (!jarg1) {
42281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42282     return 0;
42283   }
42284   std::string arg1_str(jarg1);
42285   arg1 = &arg1_str;
42286   argp2 = (Dali::ImageDimensions *)jarg2;
42287   if (!argp2) {
42288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42289     return 0;
42290   }
42291   arg2 = *argp2;
42292   arg3 = (Dali::FittingMode::Type)jarg3;
42293   arg4 = (Dali::SamplingMode::Type)jarg4;
42294   {
42295     try {
42296       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42297     } catch (std::out_of_range& e) {
42298       {
42299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42300       };
42301     } catch (std::exception& e) {
42302       {
42303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42304       };
42305     } catch (...) {
42306       {
42307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42308       };
42309     }
42310   }
42311   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42312
42313   //argout typemap for const std::string&
42314
42315   return jresult;
42316 }
42317
42318
42319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42320   void * jresult ;
42321   std::string *arg1 = 0 ;
42322   Dali::ImageDimensions arg2 ;
42323   Dali::FittingMode::Type arg3 ;
42324   Dali::ImageDimensions *argp2 ;
42325   Dali::ResourceImage result;
42326
42327   if (!jarg1) {
42328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42329     return 0;
42330   }
42331   std::string arg1_str(jarg1);
42332   arg1 = &arg1_str;
42333   argp2 = (Dali::ImageDimensions *)jarg2;
42334   if (!argp2) {
42335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42336     return 0;
42337   }
42338   arg2 = *argp2;
42339   arg3 = (Dali::FittingMode::Type)jarg3;
42340   {
42341     try {
42342       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42343     } catch (std::out_of_range& e) {
42344       {
42345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42346       };
42347     } catch (std::exception& e) {
42348       {
42349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42350       };
42351     } catch (...) {
42352       {
42353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42354       };
42355     }
42356   }
42357   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42358
42359   //argout typemap for const std::string&
42360
42361   return jresult;
42362 }
42363
42364
42365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42366   void * jresult ;
42367   std::string *arg1 = 0 ;
42368   Dali::ImageDimensions arg2 ;
42369   Dali::ImageDimensions *argp2 ;
42370   Dali::ResourceImage result;
42371
42372   if (!jarg1) {
42373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42374     return 0;
42375   }
42376   std::string arg1_str(jarg1);
42377   arg1 = &arg1_str;
42378   argp2 = (Dali::ImageDimensions *)jarg2;
42379   if (!argp2) {
42380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42381     return 0;
42382   }
42383   arg2 = *argp2;
42384   {
42385     try {
42386       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42387     } catch (std::out_of_range& e) {
42388       {
42389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42390       };
42391     } catch (std::exception& e) {
42392       {
42393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42394       };
42395     } catch (...) {
42396       {
42397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42398       };
42399     }
42400   }
42401   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42402
42403   //argout typemap for const std::string&
42404
42405   return jresult;
42406 }
42407
42408
42409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42410   void * jresult ;
42411   Dali::BaseHandle arg1 ;
42412   Dali::BaseHandle *argp1 ;
42413   Dali::ResourceImage result;
42414
42415   argp1 = (Dali::BaseHandle *)jarg1;
42416   if (!argp1) {
42417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42418     return 0;
42419   }
42420   arg1 = *argp1;
42421   {
42422     try {
42423       result = Dali::ResourceImage::DownCast(arg1);
42424     } catch (std::out_of_range& e) {
42425       {
42426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42427       };
42428     } catch (std::exception& e) {
42429       {
42430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42431       };
42432     } catch (...) {
42433       {
42434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42435       };
42436     }
42437   }
42438   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42439   return jresult;
42440 }
42441
42442
42443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42444   int jresult ;
42445   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42446   Dali::LoadingState result;
42447
42448   arg1 = (Dali::ResourceImage *)jarg1;
42449   {
42450     try {
42451       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42452     } catch (std::out_of_range& e) {
42453       {
42454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42455       };
42456     } catch (std::exception& e) {
42457       {
42458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42459       };
42460     } catch (...) {
42461       {
42462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42463       };
42464     }
42465   }
42466   jresult = (int)result;
42467   return jresult;
42468 }
42469
42470
42471 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42472   char * jresult ;
42473   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42474   std::string result;
42475
42476   arg1 = (Dali::ResourceImage *)jarg1;
42477   {
42478     try {
42479       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42480     } catch (std::out_of_range& e) {
42481       {
42482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42483       };
42484     } catch (std::exception& e) {
42485       {
42486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42487       };
42488     } catch (...) {
42489       {
42490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42491       };
42492     }
42493   }
42494   jresult = SWIG_csharp_string_callback((&result)->c_str());
42495   return jresult;
42496 }
42497
42498
42499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42500   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42501
42502   arg1 = (Dali::ResourceImage *)jarg1;
42503   {
42504     try {
42505       (arg1)->Reload();
42506     } catch (std::out_of_range& e) {
42507       {
42508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42509       };
42510     } catch (std::exception& e) {
42511       {
42512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42513       };
42514     } catch (...) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42517       };
42518     }
42519   }
42520 }
42521
42522
42523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42524   void * jresult ;
42525   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42526   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
42527
42528   arg1 = (Dali::ResourceImage *)jarg1;
42529   {
42530     try {
42531       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
42532     } catch (std::out_of_range& e) {
42533       {
42534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42535       };
42536     } catch (std::exception& e) {
42537       {
42538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42539       };
42540     } catch (...) {
42541       {
42542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42543       };
42544     }
42545   }
42546   jresult = (void *)result;
42547   return jresult;
42548 }
42549
42550
42551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
42552   void * jresult ;
42553   Dali::FrameBufferImage *result = 0 ;
42554
42555   {
42556     try {
42557       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
42558     } catch (std::out_of_range& e) {
42559       {
42560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42561       };
42562     } catch (std::exception& e) {
42563       {
42564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42565       };
42566     } catch (...) {
42567       {
42568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42569       };
42570     }
42571   }
42572   jresult = (void *)result;
42573   return jresult;
42574 }
42575
42576
42577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
42578   void * jresult ;
42579   unsigned int arg1 ;
42580   unsigned int arg2 ;
42581   Dali::Pixel::Format arg3 ;
42582   Dali::RenderBuffer::Format arg4 ;
42583   Dali::FrameBufferImage result;
42584
42585   arg1 = (unsigned int)jarg1;
42586   arg2 = (unsigned int)jarg2;
42587   arg3 = (Dali::Pixel::Format)jarg3;
42588   arg4 = (Dali::RenderBuffer::Format)jarg4;
42589   {
42590     try {
42591       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
42592     } catch (std::out_of_range& e) {
42593       {
42594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42595       };
42596     } catch (std::exception& e) {
42597       {
42598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42599       };
42600     } catch (...) {
42601       {
42602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42603       };
42604     }
42605   }
42606   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42607   return jresult;
42608 }
42609
42610
42611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
42612   void * jresult ;
42613   unsigned int arg1 ;
42614   unsigned int arg2 ;
42615   Dali::Pixel::Format arg3 ;
42616   Dali::FrameBufferImage result;
42617
42618   arg1 = (unsigned int)jarg1;
42619   arg2 = (unsigned int)jarg2;
42620   arg3 = (Dali::Pixel::Format)jarg3;
42621   {
42622     try {
42623       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
42624     } catch (std::out_of_range& e) {
42625       {
42626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42627       };
42628     } catch (std::exception& e) {
42629       {
42630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42631       };
42632     } catch (...) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42635       };
42636     }
42637   }
42638   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42639   return jresult;
42640 }
42641
42642
42643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
42644   void * jresult ;
42645   unsigned int arg1 ;
42646   unsigned int arg2 ;
42647   Dali::FrameBufferImage result;
42648
42649   arg1 = (unsigned int)jarg1;
42650   arg2 = (unsigned int)jarg2;
42651   {
42652     try {
42653       result = Dali::FrameBufferImage::New(arg1,arg2);
42654     } catch (std::out_of_range& e) {
42655       {
42656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42657       };
42658     } catch (std::exception& e) {
42659       {
42660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42661       };
42662     } catch (...) {
42663       {
42664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42665       };
42666     }
42667   }
42668   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42669   return jresult;
42670 }
42671
42672
42673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
42674   void * jresult ;
42675   unsigned int arg1 ;
42676   Dali::FrameBufferImage result;
42677
42678   arg1 = (unsigned int)jarg1;
42679   {
42680     try {
42681       result = Dali::FrameBufferImage::New(arg1);
42682     } catch (std::out_of_range& e) {
42683       {
42684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42685       };
42686     } catch (std::exception& e) {
42687       {
42688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42689       };
42690     } catch (...) {
42691       {
42692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42693       };
42694     }
42695   }
42696   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42697   return jresult;
42698 }
42699
42700
42701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
42702   void * jresult ;
42703   Dali::FrameBufferImage result;
42704
42705   {
42706     try {
42707       result = Dali::FrameBufferImage::New();
42708     } catch (std::out_of_range& e) {
42709       {
42710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42711       };
42712     } catch (std::exception& e) {
42713       {
42714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42715       };
42716     } catch (...) {
42717       {
42718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42719       };
42720     }
42721   }
42722   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42723   return jresult;
42724 }
42725
42726
42727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
42728   void * jresult ;
42729   Dali::NativeImageInterface *arg1 = 0 ;
42730   Dali::FrameBufferImage result;
42731
42732   arg1 = (Dali::NativeImageInterface *)jarg1;
42733   if (!arg1) {
42734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
42735     return 0;
42736   }
42737   {
42738     try {
42739       result = Dali::FrameBufferImage::New(*arg1);
42740     } catch (std::out_of_range& e) {
42741       {
42742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42743       };
42744     } catch (std::exception& e) {
42745       {
42746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42747       };
42748     } catch (...) {
42749       {
42750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42751       };
42752     }
42753   }
42754   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42755   return jresult;
42756 }
42757
42758
42759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
42760   void * jresult ;
42761   Dali::BaseHandle arg1 ;
42762   Dali::BaseHandle *argp1 ;
42763   Dali::FrameBufferImage result;
42764
42765   argp1 = (Dali::BaseHandle *)jarg1;
42766   if (!argp1) {
42767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42768     return 0;
42769   }
42770   arg1 = *argp1;
42771   {
42772     try {
42773       result = Dali::FrameBufferImage::DownCast(arg1);
42774     } catch (std::out_of_range& e) {
42775       {
42776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42777       };
42778     } catch (std::exception& e) {
42779       {
42780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42781       };
42782     } catch (...) {
42783       {
42784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42785       };
42786     }
42787   }
42788   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42789   return jresult;
42790 }
42791
42792
42793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
42794   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
42795
42796   arg1 = (Dali::FrameBufferImage *)jarg1;
42797   {
42798     try {
42799       delete arg1;
42800     } catch (std::out_of_range& e) {
42801       {
42802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42803       };
42804     } catch (std::exception& e) {
42805       {
42806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42807       };
42808     } catch (...) {
42809       {
42810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42811       };
42812     }
42813   }
42814 }
42815
42816
42817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
42818   void * jresult ;
42819   Dali::FrameBufferImage *arg1 = 0 ;
42820   Dali::FrameBufferImage *result = 0 ;
42821
42822   arg1 = (Dali::FrameBufferImage *)jarg1;
42823   if (!arg1) {
42824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
42825     return 0;
42826   }
42827   {
42828     try {
42829       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
42830     } catch (std::out_of_range& e) {
42831       {
42832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42833       };
42834     } catch (std::exception& e) {
42835       {
42836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42837       };
42838     } catch (...) {
42839       {
42840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42841       };
42842     }
42843   }
42844   jresult = (void *)result;
42845   return jresult;
42846 }
42847
42848
42849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
42850   void * jresult ;
42851   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
42852   Dali::FrameBufferImage *arg2 = 0 ;
42853   Dali::FrameBufferImage *result = 0 ;
42854
42855   arg1 = (Dali::FrameBufferImage *)jarg1;
42856   arg2 = (Dali::FrameBufferImage *)jarg2;
42857   if (!arg2) {
42858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
42859     return 0;
42860   }
42861   {
42862     try {
42863       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
42864     } catch (std::out_of_range& e) {
42865       {
42866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42867       };
42868     } catch (std::exception& e) {
42869       {
42870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42871       };
42872     } catch (...) {
42873       {
42874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42875       };
42876     }
42877   }
42878   jresult = (void *)result;
42879   return jresult;
42880 }
42881
42882
42883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
42884   void * jresult ;
42885   Dali::NinePatchImage *result = 0 ;
42886
42887   {
42888     try {
42889       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
42890     } catch (std::out_of_range& e) {
42891       {
42892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42893       };
42894     } catch (std::exception& e) {
42895       {
42896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42897       };
42898     } catch (...) {
42899       {
42900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42901       };
42902     }
42903   }
42904   jresult = (void *)result;
42905   return jresult;
42906 }
42907
42908
42909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
42910   void * jresult ;
42911   std::string *arg1 = 0 ;
42912   Dali::NinePatchImage result;
42913
42914   if (!jarg1) {
42915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42916     return 0;
42917   }
42918   std::string arg1_str(jarg1);
42919   arg1 = &arg1_str;
42920   {
42921     try {
42922       result = Dali::NinePatchImage::New((std::string const &)*arg1);
42923     } catch (std::out_of_range& e) {
42924       {
42925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42926       };
42927     } catch (std::exception& e) {
42928       {
42929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42930       };
42931     } catch (...) {
42932       {
42933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42934       };
42935     }
42936   }
42937   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
42938
42939   //argout typemap for const std::string&
42940
42941   return jresult;
42942 }
42943
42944
42945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
42946   void * jresult ;
42947   Dali::BaseHandle arg1 ;
42948   Dali::BaseHandle *argp1 ;
42949   Dali::NinePatchImage result;
42950
42951   argp1 = (Dali::BaseHandle *)jarg1;
42952   if (!argp1) {
42953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42954     return 0;
42955   }
42956   arg1 = *argp1;
42957   {
42958     try {
42959       result = Dali::NinePatchImage::DownCast(arg1);
42960     } catch (std::out_of_range& e) {
42961       {
42962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42963       };
42964     } catch (std::exception& e) {
42965       {
42966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42967       };
42968     } catch (...) {
42969       {
42970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42971       };
42972     }
42973   }
42974   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
42975   return jresult;
42976 }
42977
42978
42979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
42980   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
42981
42982   arg1 = (Dali::NinePatchImage *)jarg1;
42983   {
42984     try {
42985       delete arg1;
42986     } catch (std::out_of_range& e) {
42987       {
42988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42989       };
42990     } catch (std::exception& e) {
42991       {
42992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42993       };
42994     } catch (...) {
42995       {
42996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42997       };
42998     }
42999   }
43000 }
43001
43002
43003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43004   void * jresult ;
43005   Dali::NinePatchImage *arg1 = 0 ;
43006   Dali::NinePatchImage *result = 0 ;
43007
43008   arg1 = (Dali::NinePatchImage *)jarg1;
43009   if (!arg1) {
43010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43011     return 0;
43012   }
43013   {
43014     try {
43015       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43016     } catch (std::out_of_range& e) {
43017       {
43018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43019       };
43020     } catch (std::exception& e) {
43021       {
43022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43023       };
43024     } catch (...) {
43025       {
43026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43027       };
43028     }
43029   }
43030   jresult = (void *)result;
43031   return jresult;
43032 }
43033
43034
43035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43036   void * jresult ;
43037   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43038   Dali::NinePatchImage *arg2 = 0 ;
43039   Dali::NinePatchImage *result = 0 ;
43040
43041   arg1 = (Dali::NinePatchImage *)jarg1;
43042   arg2 = (Dali::NinePatchImage *)jarg2;
43043   if (!arg2) {
43044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43045     return 0;
43046   }
43047   {
43048     try {
43049       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43050     } catch (std::out_of_range& e) {
43051       {
43052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43053       };
43054     } catch (std::exception& e) {
43055       {
43056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43057       };
43058     } catch (...) {
43059       {
43060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43061       };
43062     }
43063   }
43064   jresult = (void *)result;
43065   return jresult;
43066 }
43067
43068
43069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43070   void * jresult ;
43071   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43072   Dali::Vector4 result;
43073
43074   arg1 = (Dali::NinePatchImage *)jarg1;
43075   {
43076     try {
43077       result = (arg1)->GetStretchBorders();
43078     } catch (std::out_of_range& e) {
43079       {
43080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43081       };
43082     } catch (std::exception& e) {
43083       {
43084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43085       };
43086     } catch (...) {
43087       {
43088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43089       };
43090     }
43091   }
43092   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43093   return jresult;
43094 }
43095
43096
43097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43098   void * jresult ;
43099   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43100   Dali::NinePatchImage::StretchRanges *result = 0 ;
43101
43102   arg1 = (Dali::NinePatchImage *)jarg1;
43103   {
43104     try {
43105       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43106     } catch (std::out_of_range& e) {
43107       {
43108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43109       };
43110     } catch (std::exception& e) {
43111       {
43112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43113       };
43114     } catch (...) {
43115       {
43116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43117       };
43118     }
43119   }
43120   jresult = (void *)result;
43121   return jresult;
43122 }
43123
43124
43125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43126   void * jresult ;
43127   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43128   Dali::NinePatchImage::StretchRanges *result = 0 ;
43129
43130   arg1 = (Dali::NinePatchImage *)jarg1;
43131   {
43132     try {
43133       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43134     } catch (std::out_of_range& e) {
43135       {
43136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43137       };
43138     } catch (std::exception& e) {
43139       {
43140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43141       };
43142     } catch (...) {
43143       {
43144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43145       };
43146     }
43147   }
43148   jresult = (void *)result;
43149   return jresult;
43150 }
43151
43152
43153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43154   void * jresult ;
43155   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43156   Dali::Rect< int > result;
43157
43158   arg1 = (Dali::NinePatchImage *)jarg1;
43159   {
43160     try {
43161       result = (arg1)->GetChildRectangle();
43162     } catch (std::out_of_range& e) {
43163       {
43164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43165       };
43166     } catch (std::exception& e) {
43167       {
43168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43169       };
43170     } catch (...) {
43171       {
43172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43173       };
43174     }
43175   }
43176   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43177   return jresult;
43178 }
43179
43180
43181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43182   void * jresult ;
43183   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43184   Dali::BufferImage result;
43185
43186   arg1 = (Dali::NinePatchImage *)jarg1;
43187   {
43188     try {
43189       result = (arg1)->CreateCroppedBufferImage();
43190     } catch (std::out_of_range& e) {
43191       {
43192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43193       };
43194     } catch (std::exception& e) {
43195       {
43196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43197       };
43198     } catch (...) {
43199       {
43200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43201       };
43202     }
43203   }
43204   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43205   return jresult;
43206 }
43207
43208
43209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43210   unsigned int jresult ;
43211   std::string *arg1 = 0 ;
43212   bool result;
43213
43214   if (!jarg1) {
43215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43216     return 0;
43217   }
43218   std::string arg1_str(jarg1);
43219   arg1 = &arg1_str;
43220   {
43221     try {
43222       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43223     } catch (std::out_of_range& e) {
43224       {
43225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43226       };
43227     } catch (std::exception& e) {
43228       {
43229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43230       };
43231     } catch (...) {
43232       {
43233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43234       };
43235     }
43236   }
43237   jresult = result;
43238
43239   //argout typemap for const std::string&
43240
43241   return jresult;
43242 }
43243
43244
43245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43246   int jresult ;
43247   int result;
43248
43249   result = (int)Dali::CameraActor::Property::TYPE;
43250   jresult = (int)result;
43251   return jresult;
43252 }
43253
43254
43255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43256   int jresult ;
43257   int result;
43258
43259   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43260   jresult = (int)result;
43261   return jresult;
43262 }
43263
43264
43265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43266   int jresult ;
43267   int result;
43268
43269   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43270   jresult = (int)result;
43271   return jresult;
43272 }
43273
43274
43275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43276   int jresult ;
43277   int result;
43278
43279   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43280   jresult = (int)result;
43281   return jresult;
43282 }
43283
43284
43285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43286   int jresult ;
43287   int result;
43288
43289   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43290   jresult = (int)result;
43291   return jresult;
43292 }
43293
43294
43295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43296   int jresult ;
43297   int result;
43298
43299   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43300   jresult = (int)result;
43301   return jresult;
43302 }
43303
43304
43305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43306   int jresult ;
43307   int result;
43308
43309   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43310   jresult = (int)result;
43311   return jresult;
43312 }
43313
43314
43315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43316   int jresult ;
43317   int result;
43318
43319   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43320   jresult = (int)result;
43321   return jresult;
43322 }
43323
43324
43325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43326   int jresult ;
43327   int result;
43328
43329   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43330   jresult = (int)result;
43331   return jresult;
43332 }
43333
43334
43335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43336   int jresult ;
43337   int result;
43338
43339   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43340   jresult = (int)result;
43341   return jresult;
43342 }
43343
43344
43345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43346   int jresult ;
43347   int result;
43348
43349   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43350   jresult = (int)result;
43351   return jresult;
43352 }
43353
43354
43355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43356   int jresult ;
43357   int result;
43358
43359   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43360   jresult = (int)result;
43361   return jresult;
43362 }
43363
43364
43365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43366   int jresult ;
43367   int result;
43368
43369   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43370   jresult = (int)result;
43371   return jresult;
43372 }
43373
43374
43375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43376   int jresult ;
43377   int result;
43378
43379   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43380   jresult = (int)result;
43381   return jresult;
43382 }
43383
43384
43385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43386   void * jresult ;
43387   Dali::CameraActor::Property *result = 0 ;
43388
43389   {
43390     try {
43391       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43392     } catch (std::out_of_range& e) {
43393       {
43394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43395       };
43396     } catch (std::exception& e) {
43397       {
43398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43399       };
43400     } catch (...) {
43401       {
43402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43403       };
43404     }
43405   }
43406   jresult = (void *)result;
43407   return jresult;
43408 }
43409
43410
43411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43412   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43413
43414   arg1 = (Dali::CameraActor::Property *)jarg1;
43415   {
43416     try {
43417       delete arg1;
43418     } catch (std::out_of_range& e) {
43419       {
43420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43421       };
43422     } catch (std::exception& e) {
43423       {
43424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43425       };
43426     } catch (...) {
43427       {
43428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43429       };
43430     }
43431   }
43432 }
43433
43434
43435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43436   void * jresult ;
43437   Dali::CameraActor *result = 0 ;
43438
43439   {
43440     try {
43441       result = (Dali::CameraActor *)new Dali::CameraActor();
43442     } catch (std::out_of_range& e) {
43443       {
43444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43445       };
43446     } catch (std::exception& e) {
43447       {
43448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43449       };
43450     } catch (...) {
43451       {
43452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43453       };
43454     }
43455   }
43456   jresult = (void *)result;
43457   return jresult;
43458 }
43459
43460
43461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43462   void * jresult ;
43463   Dali::CameraActor result;
43464
43465   {
43466     try {
43467       result = Dali::CameraActor::New();
43468     } catch (std::out_of_range& e) {
43469       {
43470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43471       };
43472     } catch (std::exception& e) {
43473       {
43474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43475       };
43476     } catch (...) {
43477       {
43478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43479       };
43480     }
43481   }
43482   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43483   return jresult;
43484 }
43485
43486
43487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43488   void * jresult ;
43489   Dali::Size *arg1 = 0 ;
43490   Dali::CameraActor result;
43491
43492   arg1 = (Dali::Size *)jarg1;
43493   if (!arg1) {
43494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43495     return 0;
43496   }
43497   {
43498     try {
43499       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43500     } catch (std::out_of_range& e) {
43501       {
43502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43503       };
43504     } catch (std::exception& e) {
43505       {
43506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43507       };
43508     } catch (...) {
43509       {
43510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43511       };
43512     }
43513   }
43514   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43515   return jresult;
43516 }
43517
43518
43519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
43520   void * jresult ;
43521   Dali::BaseHandle arg1 ;
43522   Dali::BaseHandle *argp1 ;
43523   Dali::CameraActor result;
43524
43525   argp1 = (Dali::BaseHandle *)jarg1;
43526   if (!argp1) {
43527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43528     return 0;
43529   }
43530   arg1 = *argp1;
43531   {
43532     try {
43533       result = Dali::CameraActor::DownCast(arg1);
43534     } catch (std::out_of_range& e) {
43535       {
43536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43537       };
43538     } catch (std::exception& e) {
43539       {
43540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43541       };
43542     } catch (...) {
43543       {
43544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43545       };
43546     }
43547   }
43548   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43549   return jresult;
43550 }
43551
43552
43553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
43554   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43555
43556   arg1 = (Dali::CameraActor *)jarg1;
43557   {
43558     try {
43559       delete arg1;
43560     } catch (std::out_of_range& e) {
43561       {
43562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43563       };
43564     } catch (std::exception& e) {
43565       {
43566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43567       };
43568     } catch (...) {
43569       {
43570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43571       };
43572     }
43573   }
43574 }
43575
43576
43577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
43578   void * jresult ;
43579   Dali::CameraActor *arg1 = 0 ;
43580   Dali::CameraActor *result = 0 ;
43581
43582   arg1 = (Dali::CameraActor *)jarg1;
43583   if (!arg1) {
43584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43585     return 0;
43586   }
43587   {
43588     try {
43589       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
43590     } catch (std::out_of_range& e) {
43591       {
43592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43593       };
43594     } catch (std::exception& e) {
43595       {
43596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43597       };
43598     } catch (...) {
43599       {
43600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43601       };
43602     }
43603   }
43604   jresult = (void *)result;
43605   return jresult;
43606 }
43607
43608
43609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
43610   void * jresult ;
43611   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43612   Dali::CameraActor *arg2 = 0 ;
43613   Dali::CameraActor *result = 0 ;
43614
43615   arg1 = (Dali::CameraActor *)jarg1;
43616   arg2 = (Dali::CameraActor *)jarg2;
43617   if (!arg2) {
43618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43619     return 0;
43620   }
43621   {
43622     try {
43623       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
43624     } catch (std::out_of_range& e) {
43625       {
43626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43627       };
43628     } catch (std::exception& e) {
43629       {
43630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43631       };
43632     } catch (...) {
43633       {
43634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43635       };
43636     }
43637   }
43638   jresult = (void *)result;
43639   return jresult;
43640 }
43641
43642
43643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
43644   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43645   Dali::Camera::Type arg2 ;
43646
43647   arg1 = (Dali::CameraActor *)jarg1;
43648   arg2 = (Dali::Camera::Type)jarg2;
43649   {
43650     try {
43651       (arg1)->SetType(arg2);
43652     } catch (std::out_of_range& e) {
43653       {
43654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43655       };
43656     } catch (std::exception& e) {
43657       {
43658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43659       };
43660     } catch (...) {
43661       {
43662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43663       };
43664     }
43665   }
43666 }
43667
43668
43669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
43670   int jresult ;
43671   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43672   Dali::Camera::Type result;
43673
43674   arg1 = (Dali::CameraActor *)jarg1;
43675   {
43676     try {
43677       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
43678     } catch (std::out_of_range& e) {
43679       {
43680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43681       };
43682     } catch (std::exception& e) {
43683       {
43684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43685       };
43686     } catch (...) {
43687       {
43688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43689       };
43690     }
43691   }
43692   jresult = (int)result;
43693   return jresult;
43694 }
43695
43696
43697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
43698   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43699   Dali::Camera::ProjectionMode arg2 ;
43700
43701   arg1 = (Dali::CameraActor *)jarg1;
43702   arg2 = (Dali::Camera::ProjectionMode)jarg2;
43703   {
43704     try {
43705       (arg1)->SetProjectionMode(arg2);
43706     } catch (std::out_of_range& e) {
43707       {
43708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43709       };
43710     } catch (std::exception& e) {
43711       {
43712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43713       };
43714     } catch (...) {
43715       {
43716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43717       };
43718     }
43719   }
43720 }
43721
43722
43723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
43724   int jresult ;
43725   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43726   Dali::Camera::ProjectionMode result;
43727
43728   arg1 = (Dali::CameraActor *)jarg1;
43729   {
43730     try {
43731       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
43732     } catch (std::out_of_range& e) {
43733       {
43734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43735       };
43736     } catch (std::exception& e) {
43737       {
43738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43739       };
43740     } catch (...) {
43741       {
43742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43743       };
43744     }
43745   }
43746   jresult = (int)result;
43747   return jresult;
43748 }
43749
43750
43751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
43752   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43753   float arg2 ;
43754
43755   arg1 = (Dali::CameraActor *)jarg1;
43756   arg2 = (float)jarg2;
43757   {
43758     try {
43759       (arg1)->SetFieldOfView(arg2);
43760     } catch (std::out_of_range& e) {
43761       {
43762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43763       };
43764     } catch (std::exception& e) {
43765       {
43766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43767       };
43768     } catch (...) {
43769       {
43770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43771       };
43772     }
43773   }
43774 }
43775
43776
43777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
43778   float jresult ;
43779   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43780   float result;
43781
43782   arg1 = (Dali::CameraActor *)jarg1;
43783   {
43784     try {
43785       result = (float)(arg1)->GetFieldOfView();
43786     } catch (std::out_of_range& e) {
43787       {
43788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43789       };
43790     } catch (std::exception& e) {
43791       {
43792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43793       };
43794     } catch (...) {
43795       {
43796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43797       };
43798     }
43799   }
43800   jresult = result;
43801   return jresult;
43802 }
43803
43804
43805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
43806   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43807   float arg2 ;
43808
43809   arg1 = (Dali::CameraActor *)jarg1;
43810   arg2 = (float)jarg2;
43811   {
43812     try {
43813       (arg1)->SetAspectRatio(arg2);
43814     } catch (std::out_of_range& e) {
43815       {
43816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43817       };
43818     } catch (std::exception& e) {
43819       {
43820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43821       };
43822     } catch (...) {
43823       {
43824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43825       };
43826     }
43827   }
43828 }
43829
43830
43831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
43832   float jresult ;
43833   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43834   float result;
43835
43836   arg1 = (Dali::CameraActor *)jarg1;
43837   {
43838     try {
43839       result = (float)(arg1)->GetAspectRatio();
43840     } catch (std::out_of_range& e) {
43841       {
43842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43843       };
43844     } catch (std::exception& e) {
43845       {
43846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43847       };
43848     } catch (...) {
43849       {
43850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43851       };
43852     }
43853   }
43854   jresult = result;
43855   return jresult;
43856 }
43857
43858
43859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
43860   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43861   float arg2 ;
43862
43863   arg1 = (Dali::CameraActor *)jarg1;
43864   arg2 = (float)jarg2;
43865   {
43866     try {
43867       (arg1)->SetNearClippingPlane(arg2);
43868     } catch (std::out_of_range& e) {
43869       {
43870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43871       };
43872     } catch (std::exception& e) {
43873       {
43874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43875       };
43876     } catch (...) {
43877       {
43878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43879       };
43880     }
43881   }
43882 }
43883
43884
43885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
43886   float jresult ;
43887   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43888   float result;
43889
43890   arg1 = (Dali::CameraActor *)jarg1;
43891   {
43892     try {
43893       result = (float)(arg1)->GetNearClippingPlane();
43894     } catch (std::out_of_range& e) {
43895       {
43896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43897       };
43898     } catch (std::exception& e) {
43899       {
43900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43901       };
43902     } catch (...) {
43903       {
43904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43905       };
43906     }
43907   }
43908   jresult = result;
43909   return jresult;
43910 }
43911
43912
43913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
43914   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43915   float arg2 ;
43916
43917   arg1 = (Dali::CameraActor *)jarg1;
43918   arg2 = (float)jarg2;
43919   {
43920     try {
43921       (arg1)->SetFarClippingPlane(arg2);
43922     } catch (std::out_of_range& e) {
43923       {
43924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43925       };
43926     } catch (std::exception& e) {
43927       {
43928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43929       };
43930     } catch (...) {
43931       {
43932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43933       };
43934     }
43935   }
43936 }
43937
43938
43939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
43940   float jresult ;
43941   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43942   float result;
43943
43944   arg1 = (Dali::CameraActor *)jarg1;
43945   {
43946     try {
43947       result = (float)(arg1)->GetFarClippingPlane();
43948     } catch (std::out_of_range& e) {
43949       {
43950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43951       };
43952     } catch (std::exception& e) {
43953       {
43954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43955       };
43956     } catch (...) {
43957       {
43958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43959       };
43960     }
43961   }
43962   jresult = result;
43963   return jresult;
43964 }
43965
43966
43967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
43968   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43969   Dali::Vector3 *arg2 = 0 ;
43970
43971   arg1 = (Dali::CameraActor *)jarg1;
43972   arg2 = (Dali::Vector3 *)jarg2;
43973   if (!arg2) {
43974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43975     return ;
43976   }
43977   {
43978     try {
43979       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
43980     } catch (std::out_of_range& e) {
43981       {
43982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43983       };
43984     } catch (std::exception& e) {
43985       {
43986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43987       };
43988     } catch (...) {
43989       {
43990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43991       };
43992     }
43993   }
43994 }
43995
43996
43997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
43998   void * jresult ;
43999   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44000   Dali::Vector3 result;
44001
44002   arg1 = (Dali::CameraActor *)jarg1;
44003   {
44004     try {
44005       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44006     } catch (std::out_of_range& e) {
44007       {
44008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44009       };
44010     } catch (std::exception& e) {
44011       {
44012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44013       };
44014     } catch (...) {
44015       {
44016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44017       };
44018     }
44019   }
44020   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44021   return jresult;
44022 }
44023
44024
44025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44026   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44027   bool arg2 ;
44028
44029   arg1 = (Dali::CameraActor *)jarg1;
44030   arg2 = jarg2 ? true : false;
44031   {
44032     try {
44033       (arg1)->SetInvertYAxis(arg2);
44034     } catch (std::out_of_range& e) {
44035       {
44036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44037       };
44038     } catch (std::exception& e) {
44039       {
44040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44041       };
44042     } catch (...) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44045       };
44046     }
44047   }
44048 }
44049
44050
44051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44052   unsigned int jresult ;
44053   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44054   bool result;
44055
44056   arg1 = (Dali::CameraActor *)jarg1;
44057   {
44058     try {
44059       result = (bool)(arg1)->GetInvertYAxis();
44060     } catch (std::out_of_range& e) {
44061       {
44062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44063       };
44064     } catch (std::exception& e) {
44065       {
44066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44067       };
44068     } catch (...) {
44069       {
44070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44071       };
44072     }
44073   }
44074   jresult = result;
44075   return jresult;
44076 }
44077
44078
44079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44080   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44081   Dali::Size *arg2 = 0 ;
44082
44083   arg1 = (Dali::CameraActor *)jarg1;
44084   arg2 = (Dali::Size *)jarg2;
44085   if (!arg2) {
44086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44087     return ;
44088   }
44089   {
44090     try {
44091       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44092     } catch (std::out_of_range& e) {
44093       {
44094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44095       };
44096     } catch (std::exception& e) {
44097       {
44098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44099       };
44100     } catch (...) {
44101       {
44102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44103       };
44104     }
44105   }
44106 }
44107
44108
44109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44110   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44111   Dali::Size *arg2 = 0 ;
44112
44113   arg1 = (Dali::CameraActor *)jarg1;
44114   arg2 = (Dali::Size *)jarg2;
44115   if (!arg2) {
44116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44117     return ;
44118   }
44119   {
44120     try {
44121       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44122     } catch (std::out_of_range& e) {
44123       {
44124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44125       };
44126     } catch (std::exception& e) {
44127       {
44128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44129       };
44130     } catch (...) {
44131       {
44132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44133       };
44134     }
44135   }
44136 }
44137
44138
44139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44140   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44141   float arg2 ;
44142   float arg3 ;
44143   float arg4 ;
44144   float arg5 ;
44145   float arg6 ;
44146   float arg7 ;
44147
44148   arg1 = (Dali::CameraActor *)jarg1;
44149   arg2 = (float)jarg2;
44150   arg3 = (float)jarg3;
44151   arg4 = (float)jarg4;
44152   arg5 = (float)jarg5;
44153   arg6 = (float)jarg6;
44154   arg7 = (float)jarg7;
44155   {
44156     try {
44157       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44158     } catch (std::out_of_range& e) {
44159       {
44160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44161       };
44162     } catch (std::exception& e) {
44163       {
44164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44165       };
44166     } catch (...) {
44167       {
44168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44169       };
44170     }
44171   }
44172 }
44173
44174
44175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44176   void * jresult ;
44177   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44178
44179   {
44180     try {
44181       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44182     } catch (std::out_of_range& e) {
44183       {
44184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44185       };
44186     } catch (std::exception& e) {
44187       {
44188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44189       };
44190     } catch (...) {
44191       {
44192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44193       };
44194     }
44195   }
44196   jresult = (void *)result;
44197   return jresult;
44198 }
44199
44200
44201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44202   void * jresult ;
44203   std::string arg1 ;
44204   Dali::Property::Value arg2 ;
44205   Dali::Property::Value *argp2 ;
44206   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44207
44208   if (!jarg1) {
44209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44210     return 0;
44211   }
44212   (&arg1)->assign(jarg1);
44213   argp2 = (Dali::Property::Value *)jarg2;
44214   if (!argp2) {
44215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44216     return 0;
44217   }
44218   arg2 = *argp2;
44219   {
44220     try {
44221       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44222     } catch (std::out_of_range& e) {
44223       {
44224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44225       };
44226     } catch (std::exception& e) {
44227       {
44228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44229       };
44230     } catch (...) {
44231       {
44232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44233       };
44234     }
44235   }
44236   jresult = (void *)result;
44237   return jresult;
44238 }
44239
44240
44241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44242   void * jresult ;
44243   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44244   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44245
44246   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44247   if (!arg1) {
44248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44249     return 0;
44250   }
44251   {
44252     try {
44253       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);
44254     } catch (std::out_of_range& e) {
44255       {
44256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44257       };
44258     } catch (std::exception& e) {
44259       {
44260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44261       };
44262     } catch (...) {
44263       {
44264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44265       };
44266     }
44267   }
44268   jresult = (void *)result;
44269   return jresult;
44270 }
44271
44272
44273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44274   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44275   std::string *arg2 = 0 ;
44276
44277   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44278   if (!jarg2) {
44279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44280     return ;
44281   }
44282   std::string arg2_str(jarg2);
44283   arg2 = &arg2_str;
44284   if (arg1) (arg1)->first = *arg2;
44285
44286   //argout typemap for const std::string&
44287
44288 }
44289
44290
44291 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44292   char * jresult ;
44293   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44294   std::string *result = 0 ;
44295
44296   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44297   result = (std::string *) & ((arg1)->first);
44298   jresult = SWIG_csharp_string_callback(result->c_str());
44299   return jresult;
44300 }
44301
44302
44303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44304   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44305   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44306
44307   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44308   arg2 = (Dali::Property::Value *)jarg2;
44309   if (arg1) (arg1)->second = *arg2;
44310 }
44311
44312
44313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44314   void * jresult ;
44315   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44316   Dali::Property::Value *result = 0 ;
44317
44318   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44319   result = (Dali::Property::Value *)& ((arg1)->second);
44320   jresult = (void *)result;
44321   return jresult;
44322 }
44323
44324
44325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44326   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44327
44328   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44329   {
44330     try {
44331       delete arg1;
44332     } catch (std::out_of_range& e) {
44333       {
44334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44335       };
44336     } catch (std::exception& e) {
44337       {
44338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44339       };
44340     } catch (...) {
44341       {
44342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44343       };
44344     }
44345   }
44346 }
44347
44348
44349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44350   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44351
44352   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44353   {
44354     try {
44355       (arg1)->clear();
44356     } catch (std::out_of_range& e) {
44357       {
44358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44359       };
44360     } catch (std::exception& e) {
44361       {
44362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44363       };
44364     } catch (...) {
44365       {
44366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44367       };
44368     }
44369   }
44370 }
44371
44372
44373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44374   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44375   Dali::TouchPoint *arg2 = 0 ;
44376
44377   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44378   arg2 = (Dali::TouchPoint *)jarg2;
44379   if (!arg2) {
44380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44381     return ;
44382   }
44383   {
44384     try {
44385       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44386     } catch (std::out_of_range& e) {
44387       {
44388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44389       };
44390     } catch (std::exception& e) {
44391       {
44392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44393       };
44394     } catch (...) {
44395       {
44396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44397       };
44398     }
44399   }
44400 }
44401
44402
44403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44404   unsigned long jresult ;
44405   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44406   std::vector< Dali::TouchPoint >::size_type result;
44407
44408   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44409   {
44410     try {
44411       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44412     } catch (std::out_of_range& e) {
44413       {
44414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44415       };
44416     } catch (std::exception& e) {
44417       {
44418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44419       };
44420     } catch (...) {
44421       {
44422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44423       };
44424     }
44425   }
44426   jresult = (unsigned long)result;
44427   return jresult;
44428 }
44429
44430
44431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44432   unsigned long jresult ;
44433   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44434   std::vector< Dali::TouchPoint >::size_type result;
44435
44436   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44437   {
44438     try {
44439       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44440     } catch (std::out_of_range& e) {
44441       {
44442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44443       };
44444     } catch (std::exception& e) {
44445       {
44446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44447       };
44448     } catch (...) {
44449       {
44450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44451       };
44452     }
44453   }
44454   jresult = (unsigned long)result;
44455   return jresult;
44456 }
44457
44458
44459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44460   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44461   std::vector< Dali::TouchPoint >::size_type arg2 ;
44462
44463   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44464   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44465   {
44466     try {
44467       (arg1)->reserve(arg2);
44468     } catch (std::out_of_range& e) {
44469       {
44470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44471       };
44472     } catch (std::exception& e) {
44473       {
44474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44475       };
44476     } catch (...) {
44477       {
44478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44479       };
44480     }
44481   }
44482 }
44483
44484
44485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44486   void * jresult ;
44487   std::vector< Dali::TouchPoint > *result = 0 ;
44488
44489   {
44490     try {
44491       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44492     } catch (std::out_of_range& e) {
44493       {
44494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44495       };
44496     } catch (std::exception& e) {
44497       {
44498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44499       };
44500     } catch (...) {
44501       {
44502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44503       };
44504     }
44505   }
44506   jresult = (void *)result;
44507   return jresult;
44508 }
44509
44510
44511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
44512   void * jresult ;
44513   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44514   std::vector< Dali::TouchPoint > *result = 0 ;
44515
44516   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44517   if (!arg1) {
44518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44519     return 0;
44520   }
44521   {
44522     try {
44523       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44524     } catch (std::out_of_range& e) {
44525       {
44526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44527       };
44528     } catch (std::exception& e) {
44529       {
44530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44531       };
44532     } catch (...) {
44533       {
44534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44535       };
44536     }
44537   }
44538   jresult = (void *)result;
44539   return jresult;
44540 }
44541
44542
44543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
44544   void * jresult ;
44545   int arg1 ;
44546   std::vector< Dali::TouchPoint > *result = 0 ;
44547
44548   arg1 = (int)jarg1;
44549   {
44550     try {
44551       try {
44552         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
44553       }
44554       catch(std::out_of_range &_e) {
44555         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44556         return 0;
44557       }
44558
44559     } catch (std::out_of_range& e) {
44560       {
44561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44562       };
44563     } catch (std::exception& e) {
44564       {
44565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44566       };
44567     } catch (...) {
44568       {
44569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44570       };
44571     }
44572   }
44573   jresult = (void *)result;
44574   return jresult;
44575 }
44576
44577
44578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
44579   void * jresult ;
44580   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44581   int arg2 ;
44582   SwigValueWrapper< Dali::TouchPoint > result;
44583
44584   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44585   arg2 = (int)jarg2;
44586   {
44587     try {
44588       try {
44589         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
44590       }
44591       catch(std::out_of_range &_e) {
44592         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44593         return 0;
44594       }
44595
44596     } catch (std::out_of_range& e) {
44597       {
44598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44599       };
44600     } catch (std::exception& e) {
44601       {
44602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44603       };
44604     } catch (...) {
44605       {
44606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44607       };
44608     }
44609   }
44610   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
44611   return jresult;
44612 }
44613
44614
44615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
44616   void * jresult ;
44617   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44618   int arg2 ;
44619   Dali::TouchPoint *result = 0 ;
44620
44621   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44622   arg2 = (int)jarg2;
44623   {
44624     try {
44625       try {
44626         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
44627       }
44628       catch(std::out_of_range &_e) {
44629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44630         return 0;
44631       }
44632
44633     } catch (std::out_of_range& e) {
44634       {
44635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44636       };
44637     } catch (std::exception& e) {
44638       {
44639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44640       };
44641     } catch (...) {
44642       {
44643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44644       };
44645     }
44646   }
44647   jresult = (void *)result;
44648   return jresult;
44649 }
44650
44651
44652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
44653   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44654   int arg2 ;
44655   Dali::TouchPoint *arg3 = 0 ;
44656
44657   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44658   arg2 = (int)jarg2;
44659   arg3 = (Dali::TouchPoint *)jarg3;
44660   if (!arg3) {
44661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44662     return ;
44663   }
44664   {
44665     try {
44666       try {
44667         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44668       }
44669       catch(std::out_of_range &_e) {
44670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44671         return ;
44672       }
44673
44674     } catch (std::out_of_range& e) {
44675       {
44676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44677       };
44678     } catch (std::exception& e) {
44679       {
44680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44681       };
44682     } catch (...) {
44683       {
44684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44685       };
44686     }
44687   }
44688 }
44689
44690
44691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
44692   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44693   std::vector< Dali::TouchPoint > *arg2 = 0 ;
44694
44695   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44696   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
44697   if (!arg2) {
44698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44699     return ;
44700   }
44701   {
44702     try {
44703       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
44704     } catch (std::out_of_range& e) {
44705       {
44706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44707       };
44708     } catch (std::exception& e) {
44709       {
44710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44711       };
44712     } catch (...) {
44713       {
44714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44715       };
44716     }
44717   }
44718 }
44719
44720
44721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
44722   void * jresult ;
44723   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44724   int arg2 ;
44725   int arg3 ;
44726   std::vector< Dali::TouchPoint > *result = 0 ;
44727
44728   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44729   arg2 = (int)jarg2;
44730   arg3 = (int)jarg3;
44731   {
44732     try {
44733       try {
44734         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
44735       }
44736       catch(std::out_of_range &_e) {
44737         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44738         return 0;
44739       }
44740       catch(std::invalid_argument &_e) {
44741         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
44742         return 0;
44743       }
44744
44745     } catch (std::out_of_range& e) {
44746       {
44747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44748       };
44749     } catch (std::exception& e) {
44750       {
44751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44752       };
44753     } catch (...) {
44754       {
44755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44756       };
44757     }
44758   }
44759   jresult = (void *)result;
44760   return jresult;
44761 }
44762
44763
44764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
44765   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44766   int arg2 ;
44767   Dali::TouchPoint *arg3 = 0 ;
44768
44769   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44770   arg2 = (int)jarg2;
44771   arg3 = (Dali::TouchPoint *)jarg3;
44772   if (!arg3) {
44773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44774     return ;
44775   }
44776   {
44777     try {
44778       try {
44779         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44780       }
44781       catch(std::out_of_range &_e) {
44782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44783         return ;
44784       }
44785
44786     } catch (std::out_of_range& e) {
44787       {
44788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44789       };
44790     } catch (std::exception& e) {
44791       {
44792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44793       };
44794     } catch (...) {
44795       {
44796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44797       };
44798     }
44799   }
44800 }
44801
44802
44803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
44804   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44805   int arg2 ;
44806   std::vector< Dali::TouchPoint > *arg3 = 0 ;
44807
44808   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44809   arg2 = (int)jarg2;
44810   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
44811   if (!arg3) {
44812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44813     return ;
44814   }
44815   {
44816     try {
44817       try {
44818         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
44819       }
44820       catch(std::out_of_range &_e) {
44821         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44822         return ;
44823       }
44824
44825     } catch (std::out_of_range& e) {
44826       {
44827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44828       };
44829     } catch (std::exception& e) {
44830       {
44831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44832       };
44833     } catch (...) {
44834       {
44835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44836       };
44837     }
44838   }
44839 }
44840
44841
44842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
44843   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44844   int arg2 ;
44845
44846   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44847   arg2 = (int)jarg2;
44848   {
44849     try {
44850       try {
44851         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
44852       }
44853       catch(std::out_of_range &_e) {
44854         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44855         return ;
44856       }
44857
44858     } catch (std::out_of_range& e) {
44859       {
44860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44861       };
44862     } catch (std::exception& e) {
44863       {
44864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44865       };
44866     } catch (...) {
44867       {
44868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44869       };
44870     }
44871   }
44872 }
44873
44874
44875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
44876   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44877   int arg2 ;
44878   int arg3 ;
44879
44880   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44881   arg2 = (int)jarg2;
44882   arg3 = (int)jarg3;
44883   {
44884     try {
44885       try {
44886         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
44887       }
44888       catch(std::out_of_range &_e) {
44889         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44890         return ;
44891       }
44892       catch(std::invalid_argument &_e) {
44893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
44894         return ;
44895       }
44896
44897     } catch (std::out_of_range& e) {
44898       {
44899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44900       };
44901     } catch (std::exception& e) {
44902       {
44903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44904       };
44905     } catch (...) {
44906       {
44907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44908       };
44909     }
44910   }
44911 }
44912
44913
44914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
44915   void * jresult ;
44916   Dali::TouchPoint *arg1 = 0 ;
44917   int arg2 ;
44918   std::vector< Dali::TouchPoint > *result = 0 ;
44919
44920   arg1 = (Dali::TouchPoint *)jarg1;
44921   if (!arg1) {
44922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44923     return 0;
44924   }
44925   arg2 = (int)jarg2;
44926   {
44927     try {
44928       try {
44929         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
44930       }
44931       catch(std::out_of_range &_e) {
44932         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44933         return 0;
44934       }
44935
44936     } catch (std::out_of_range& e) {
44937       {
44938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44939       };
44940     } catch (std::exception& e) {
44941       {
44942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44943       };
44944     } catch (...) {
44945       {
44946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44947       };
44948     }
44949   }
44950   jresult = (void *)result;
44951   return jresult;
44952 }
44953
44954
44955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
44956   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44957
44958   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44959   {
44960     try {
44961       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
44962     } catch (std::out_of_range& e) {
44963       {
44964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44965       };
44966     } catch (std::exception& e) {
44967       {
44968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44969       };
44970     } catch (...) {
44971       {
44972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44973       };
44974     }
44975   }
44976 }
44977
44978
44979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
44980   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44981   int arg2 ;
44982   int arg3 ;
44983
44984   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44985   arg2 = (int)jarg2;
44986   arg3 = (int)jarg3;
44987   {
44988     try {
44989       try {
44990         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
44991       }
44992       catch(std::out_of_range &_e) {
44993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44994         return ;
44995       }
44996       catch(std::invalid_argument &_e) {
44997         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
44998         return ;
44999       }
45000
45001     } catch (std::out_of_range& e) {
45002       {
45003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45004       };
45005     } catch (std::exception& e) {
45006       {
45007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45008       };
45009     } catch (...) {
45010       {
45011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45012       };
45013     }
45014   }
45015 }
45016
45017
45018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45019   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45020   int arg2 ;
45021   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45022
45023   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45024   arg2 = (int)jarg2;
45025   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45026   if (!arg3) {
45027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45028     return ;
45029   }
45030   {
45031     try {
45032       try {
45033         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45034       }
45035       catch(std::out_of_range &_e) {
45036         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45037         return ;
45038       }
45039
45040     } catch (std::out_of_range& e) {
45041       {
45042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45043       };
45044     } catch (std::exception& e) {
45045       {
45046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45047       };
45048     } catch (...) {
45049       {
45050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45051       };
45052     }
45053   }
45054 }
45055
45056
45057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45058   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45059
45060   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45061   {
45062     try {
45063       delete arg1;
45064     } catch (std::out_of_range& e) {
45065       {
45066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45067       };
45068     } catch (std::exception& e) {
45069       {
45070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45071       };
45072     } catch (...) {
45073       {
45074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45075       };
45076     }
45077   }
45078 }
45079
45080
45081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45082   void * jresult ;
45083   Dali::Rect< int > *result = 0 ;
45084
45085   {
45086     try {
45087       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45088     } catch (std::out_of_range& e) {
45089       {
45090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45091       };
45092     } catch (std::exception& e) {
45093       {
45094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45095       };
45096     } catch (...) {
45097       {
45098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45099       };
45100     }
45101   }
45102   jresult = (void *)result;
45103   return jresult;
45104 }
45105
45106
45107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45108   void * jresult ;
45109   int arg1 ;
45110   int arg2 ;
45111   int arg3 ;
45112   int arg4 ;
45113   Dali::Rect< int > *result = 0 ;
45114
45115   arg1 = (int)jarg1;
45116   arg2 = (int)jarg2;
45117   arg3 = (int)jarg3;
45118   arg4 = (int)jarg4;
45119   {
45120     try {
45121       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45122     } catch (std::out_of_range& e) {
45123       {
45124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45125       };
45126     } catch (std::exception& e) {
45127       {
45128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45129       };
45130     } catch (...) {
45131       {
45132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45133       };
45134     }
45135   }
45136   jresult = (void *)result;
45137   return jresult;
45138 }
45139
45140
45141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45142   void * jresult ;
45143   Dali::Rect< int > *arg1 = 0 ;
45144   Dali::Rect< int > *result = 0 ;
45145
45146   arg1 = (Dali::Rect< int > *)jarg1;
45147   if (!arg1) {
45148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45149     return 0;
45150   }
45151   {
45152     try {
45153       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45154     } catch (std::out_of_range& e) {
45155       {
45156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45157       };
45158     } catch (std::exception& e) {
45159       {
45160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45161       };
45162     } catch (...) {
45163       {
45164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45165       };
45166     }
45167   }
45168   jresult = (void *)result;
45169   return jresult;
45170 }
45171
45172
45173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45174   void * jresult ;
45175   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45176   Dali::Rect< int > *arg2 = 0 ;
45177   Dali::Rect< int > *result = 0 ;
45178
45179   arg1 = (Dali::Rect< int > *)jarg1;
45180   arg2 = (Dali::Rect< int > *)jarg2;
45181   if (!arg2) {
45182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45183     return 0;
45184   }
45185   {
45186     try {
45187       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45188     } catch (std::out_of_range& e) {
45189       {
45190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45191       };
45192     } catch (std::exception& e) {
45193       {
45194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45195       };
45196     } catch (...) {
45197       {
45198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45199       };
45200     }
45201   }
45202   jresult = (void *)result;
45203   return jresult;
45204 }
45205
45206
45207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45208   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45209   int arg2 ;
45210   int arg3 ;
45211   int arg4 ;
45212   int arg5 ;
45213
45214   arg1 = (Dali::Rect< int > *)jarg1;
45215   arg2 = (int)jarg2;
45216   arg3 = (int)jarg3;
45217   arg4 = (int)jarg4;
45218   arg5 = (int)jarg5;
45219   {
45220     try {
45221       (arg1)->Set(arg2,arg3,arg4,arg5);
45222     } catch (std::out_of_range& e) {
45223       {
45224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45225       };
45226     } catch (std::exception& e) {
45227       {
45228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45229       };
45230     } catch (...) {
45231       {
45232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45233       };
45234     }
45235   }
45236 }
45237
45238
45239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45240   unsigned int jresult ;
45241   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45242   bool result;
45243
45244   arg1 = (Dali::Rect< int > *)jarg1;
45245   {
45246     try {
45247       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45248     } catch (std::out_of_range& e) {
45249       {
45250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45251       };
45252     } catch (std::exception& e) {
45253       {
45254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45255       };
45256     } catch (...) {
45257       {
45258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45259       };
45260     }
45261   }
45262   jresult = result;
45263   return jresult;
45264 }
45265
45266
45267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45268   int jresult ;
45269   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45270   int result;
45271
45272   arg1 = (Dali::Rect< int > *)jarg1;
45273   {
45274     try {
45275       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45276     } catch (std::out_of_range& e) {
45277       {
45278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45279       };
45280     } catch (std::exception& e) {
45281       {
45282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45283       };
45284     } catch (...) {
45285       {
45286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45287       };
45288     }
45289   }
45290   jresult = result;
45291   return jresult;
45292 }
45293
45294
45295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45296   int jresult ;
45297   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45298   int result;
45299
45300   arg1 = (Dali::Rect< int > *)jarg1;
45301   {
45302     try {
45303       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45304     } catch (std::out_of_range& e) {
45305       {
45306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45307       };
45308     } catch (std::exception& e) {
45309       {
45310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45311       };
45312     } catch (...) {
45313       {
45314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45315       };
45316     }
45317   }
45318   jresult = result;
45319   return jresult;
45320 }
45321
45322
45323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45324   int jresult ;
45325   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45326   int result;
45327
45328   arg1 = (Dali::Rect< int > *)jarg1;
45329   {
45330     try {
45331       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45332     } catch (std::out_of_range& e) {
45333       {
45334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45335       };
45336     } catch (std::exception& e) {
45337       {
45338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45339       };
45340     } catch (...) {
45341       {
45342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45343       };
45344     }
45345   }
45346   jresult = result;
45347   return jresult;
45348 }
45349
45350
45351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45352   int jresult ;
45353   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45354   int result;
45355
45356   arg1 = (Dali::Rect< int > *)jarg1;
45357   {
45358     try {
45359       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45360     } catch (std::out_of_range& e) {
45361       {
45362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45363       };
45364     } catch (std::exception& e) {
45365       {
45366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45367       };
45368     } catch (...) {
45369       {
45370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45371       };
45372     }
45373   }
45374   jresult = result;
45375   return jresult;
45376 }
45377
45378
45379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45380   int jresult ;
45381   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45382   int result;
45383
45384   arg1 = (Dali::Rect< int > *)jarg1;
45385   {
45386     try {
45387       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45388     } catch (std::out_of_range& e) {
45389       {
45390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45391       };
45392     } catch (std::exception& e) {
45393       {
45394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45395       };
45396     } catch (...) {
45397       {
45398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45399       };
45400     }
45401   }
45402   jresult = result;
45403   return jresult;
45404 }
45405
45406
45407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45408   unsigned int jresult ;
45409   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45410   Dali::Rect< int > *arg2 = 0 ;
45411   bool result;
45412
45413   arg1 = (Dali::Rect< int > *)jarg1;
45414   arg2 = (Dali::Rect< int > *)jarg2;
45415   if (!arg2) {
45416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45417     return 0;
45418   }
45419   {
45420     try {
45421       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45422     } catch (std::out_of_range& e) {
45423       {
45424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45425       };
45426     } catch (std::exception& e) {
45427       {
45428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45429       };
45430     } catch (...) {
45431       {
45432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45433       };
45434     }
45435   }
45436   jresult = result;
45437   return jresult;
45438 }
45439
45440
45441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45442   unsigned int jresult ;
45443   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45444   Dali::Rect< int > *arg2 = 0 ;
45445   bool result;
45446
45447   arg1 = (Dali::Rect< int > *)jarg1;
45448   arg2 = (Dali::Rect< int > *)jarg2;
45449   if (!arg2) {
45450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45451     return 0;
45452   }
45453   {
45454     try {
45455       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45456     } catch (std::out_of_range& e) {
45457       {
45458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45459       };
45460     } catch (std::exception& e) {
45461       {
45462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45463       };
45464     } catch (...) {
45465       {
45466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45467       };
45468     }
45469   }
45470   jresult = result;
45471   return jresult;
45472 }
45473
45474
45475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45476   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45477   int arg2 ;
45478
45479   arg1 = (Dali::Rect< int > *)jarg1;
45480   arg2 = (int)jarg2;
45481   if (arg1) (arg1)->x = arg2;
45482 }
45483
45484
45485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45486   int jresult ;
45487   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45488   int result;
45489
45490   arg1 = (Dali::Rect< int > *)jarg1;
45491   result = (int) ((arg1)->x);
45492   jresult = result;
45493   return jresult;
45494 }
45495
45496
45497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45498   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45499   int arg2 ;
45500
45501   arg1 = (Dali::Rect< int > *)jarg1;
45502   arg2 = (int)jarg2;
45503   if (arg1) (arg1)->left = arg2;
45504 }
45505
45506
45507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
45508   int jresult ;
45509   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45510   int result;
45511
45512   arg1 = (Dali::Rect< int > *)jarg1;
45513   result = (int) ((arg1)->left);
45514   jresult = result;
45515   return jresult;
45516 }
45517
45518
45519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
45520   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45521   int arg2 ;
45522
45523   arg1 = (Dali::Rect< int > *)jarg1;
45524   arg2 = (int)jarg2;
45525   if (arg1) (arg1)->y = arg2;
45526 }
45527
45528
45529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
45530   int jresult ;
45531   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45532   int result;
45533
45534   arg1 = (Dali::Rect< int > *)jarg1;
45535   result = (int) ((arg1)->y);
45536   jresult = result;
45537   return jresult;
45538 }
45539
45540
45541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
45542   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45543   int arg2 ;
45544
45545   arg1 = (Dali::Rect< int > *)jarg1;
45546   arg2 = (int)jarg2;
45547   if (arg1) (arg1)->right = arg2;
45548 }
45549
45550
45551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
45552   int jresult ;
45553   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45554   int result;
45555
45556   arg1 = (Dali::Rect< int > *)jarg1;
45557   result = (int) ((arg1)->right);
45558   jresult = result;
45559   return jresult;
45560 }
45561
45562
45563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
45564   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45565   int arg2 ;
45566
45567   arg1 = (Dali::Rect< int > *)jarg1;
45568   arg2 = (int)jarg2;
45569   if (arg1) (arg1)->width = arg2;
45570 }
45571
45572
45573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
45574   int jresult ;
45575   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45576   int result;
45577
45578   arg1 = (Dali::Rect< int > *)jarg1;
45579   result = (int) ((arg1)->width);
45580   jresult = result;
45581   return jresult;
45582 }
45583
45584
45585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
45586   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45587   int arg2 ;
45588
45589   arg1 = (Dali::Rect< int > *)jarg1;
45590   arg2 = (int)jarg2;
45591   if (arg1) (arg1)->bottom = arg2;
45592 }
45593
45594
45595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
45596   int jresult ;
45597   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45598   int result;
45599
45600   arg1 = (Dali::Rect< int > *)jarg1;
45601   result = (int) ((arg1)->bottom);
45602   jresult = result;
45603   return jresult;
45604 }
45605
45606
45607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
45608   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45609   int arg2 ;
45610
45611   arg1 = (Dali::Rect< int > *)jarg1;
45612   arg2 = (int)jarg2;
45613   if (arg1) (arg1)->height = arg2;
45614 }
45615
45616
45617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
45618   int jresult ;
45619   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45620   int result;
45621
45622   arg1 = (Dali::Rect< int > *)jarg1;
45623   result = (int) ((arg1)->height);
45624   jresult = result;
45625   return jresult;
45626 }
45627
45628
45629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
45630   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45631   int arg2 ;
45632
45633   arg1 = (Dali::Rect< int > *)jarg1;
45634   arg2 = (int)jarg2;
45635   if (arg1) (arg1)->top = arg2;
45636 }
45637
45638
45639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
45640   int jresult ;
45641   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45642   int result;
45643
45644   arg1 = (Dali::Rect< int > *)jarg1;
45645   result = (int) ((arg1)->top);
45646   jresult = result;
45647   return jresult;
45648 }
45649
45650
45651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
45652   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45653
45654   arg1 = (Dali::Rect< int > *)jarg1;
45655   {
45656     try {
45657       delete arg1;
45658     } catch (std::out_of_range& e) {
45659       {
45660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45661       };
45662     } catch (std::exception& e) {
45663       {
45664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45665       };
45666     } catch (...) {
45667       {
45668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45669       };
45670     }
45671   }
45672 }
45673
45674
45675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
45676   void * jresult ;
45677   Dali::Rect< float > *result = 0 ;
45678
45679   {
45680     try {
45681       result = (Dali::Rect< float > *)new Dali::Rect< float >();
45682     } catch (std::out_of_range& e) {
45683       {
45684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45685       };
45686     } catch (std::exception& e) {
45687       {
45688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45689       };
45690     } catch (...) {
45691       {
45692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45693       };
45694     }
45695   }
45696   jresult = (void *)result;
45697   return jresult;
45698 }
45699
45700
45701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
45702   void * jresult ;
45703   float arg1 ;
45704   float arg2 ;
45705   float arg3 ;
45706   float arg4 ;
45707   Dali::Rect< float > *result = 0 ;
45708
45709   arg1 = (float)jarg1;
45710   arg2 = (float)jarg2;
45711   arg3 = (float)jarg3;
45712   arg4 = (float)jarg4;
45713   {
45714     try {
45715       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
45716     } catch (std::out_of_range& e) {
45717       {
45718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45719       };
45720     } catch (std::exception& e) {
45721       {
45722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45723       };
45724     } catch (...) {
45725       {
45726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45727       };
45728     }
45729   }
45730   jresult = (void *)result;
45731   return jresult;
45732 }
45733
45734
45735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
45736   void * jresult ;
45737   Dali::Rect< float > *arg1 = 0 ;
45738   Dali::Rect< float > *result = 0 ;
45739
45740   arg1 = (Dali::Rect< float > *)jarg1;
45741   if (!arg1) {
45742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
45743     return 0;
45744   }
45745   {
45746     try {
45747       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
45748     } catch (std::out_of_range& e) {
45749       {
45750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45751       };
45752     } catch (std::exception& e) {
45753       {
45754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45755       };
45756     } catch (...) {
45757       {
45758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45759       };
45760     }
45761   }
45762   jresult = (void *)result;
45763   return jresult;
45764 }
45765
45766
45767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
45768   void * jresult ;
45769   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45770   Dali::Rect< float > *arg2 = 0 ;
45771   Dali::Rect< float > *result = 0 ;
45772
45773   arg1 = (Dali::Rect< float > *)jarg1;
45774   arg2 = (Dali::Rect< float > *)jarg2;
45775   if (!arg2) {
45776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
45777     return 0;
45778   }
45779   {
45780     try {
45781       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
45782     } catch (std::out_of_range& e) {
45783       {
45784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45785       };
45786     } catch (std::exception& e) {
45787       {
45788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45789       };
45790     } catch (...) {
45791       {
45792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45793       };
45794     }
45795   }
45796   jresult = (void *)result;
45797   return jresult;
45798 }
45799
45800
45801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
45802   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45803   float arg2 ;
45804   float arg3 ;
45805   float arg4 ;
45806   float arg5 ;
45807
45808   arg1 = (Dali::Rect< float > *)jarg1;
45809   arg2 = (float)jarg2;
45810   arg3 = (float)jarg3;
45811   arg4 = (float)jarg4;
45812   arg5 = (float)jarg5;
45813   {
45814     try {
45815       (arg1)->Set(arg2,arg3,arg4,arg5);
45816     } catch (std::out_of_range& e) {
45817       {
45818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45819       };
45820     } catch (std::exception& e) {
45821       {
45822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45823       };
45824     } catch (...) {
45825       {
45826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45827       };
45828     }
45829   }
45830 }
45831
45832
45833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
45834   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45835   float arg2 ;
45836
45837   arg1 = (Dali::Rect< float > *)jarg1;
45838   arg2 = (float)jarg2;
45839   if (arg1) (arg1)->x = arg2;
45840 }
45841
45842
45843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
45844   float jresult ;
45845   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45846   float result;
45847
45848   arg1 = (Dali::Rect< float > *)jarg1;
45849   result = (float) ((arg1)->x);
45850   jresult = result;
45851   return jresult;
45852 }
45853
45854
45855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
45856   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45857   float arg2 ;
45858
45859   arg1 = (Dali::Rect< float > *)jarg1;
45860   arg2 = (float)jarg2;
45861   if (arg1) (arg1)->left = arg2;
45862 }
45863
45864
45865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
45866   float jresult ;
45867   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45868   float result;
45869
45870   arg1 = (Dali::Rect< float > *)jarg1;
45871   result = (float) ((arg1)->left);
45872   jresult = result;
45873   return jresult;
45874 }
45875
45876
45877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
45878   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45879   float arg2 ;
45880
45881   arg1 = (Dali::Rect< float > *)jarg1;
45882   arg2 = (float)jarg2;
45883   if (arg1) (arg1)->y = arg2;
45884 }
45885
45886
45887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
45888   float jresult ;
45889   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45890   float result;
45891
45892   arg1 = (Dali::Rect< float > *)jarg1;
45893   result = (float) ((arg1)->y);
45894   jresult = result;
45895   return jresult;
45896 }
45897
45898
45899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
45900   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45901   float arg2 ;
45902
45903   arg1 = (Dali::Rect< float > *)jarg1;
45904   arg2 = (float)jarg2;
45905   if (arg1) (arg1)->right = arg2;
45906 }
45907
45908
45909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
45910   float jresult ;
45911   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45912   float result;
45913
45914   arg1 = (Dali::Rect< float > *)jarg1;
45915   result = (float) ((arg1)->right);
45916   jresult = result;
45917   return jresult;
45918 }
45919
45920
45921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
45922   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45923   float arg2 ;
45924
45925   arg1 = (Dali::Rect< float > *)jarg1;
45926   arg2 = (float)jarg2;
45927   if (arg1) (arg1)->width = arg2;
45928 }
45929
45930
45931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
45932   float jresult ;
45933   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45934   float result;
45935
45936   arg1 = (Dali::Rect< float > *)jarg1;
45937   result = (float) ((arg1)->width);
45938   jresult = result;
45939   return jresult;
45940 }
45941
45942
45943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
45944   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45945   float arg2 ;
45946
45947   arg1 = (Dali::Rect< float > *)jarg1;
45948   arg2 = (float)jarg2;
45949   if (arg1) (arg1)->bottom = arg2;
45950 }
45951
45952
45953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
45954   float jresult ;
45955   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45956   float result;
45957
45958   arg1 = (Dali::Rect< float > *)jarg1;
45959   result = (float) ((arg1)->bottom);
45960   jresult = result;
45961   return jresult;
45962 }
45963
45964
45965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
45966   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45967   float arg2 ;
45968
45969   arg1 = (Dali::Rect< float > *)jarg1;
45970   arg2 = (float)jarg2;
45971   if (arg1) (arg1)->height = arg2;
45972 }
45973
45974
45975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
45976   float jresult ;
45977   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45978   float result;
45979
45980   arg1 = (Dali::Rect< float > *)jarg1;
45981   result = (float) ((arg1)->height);
45982   jresult = result;
45983   return jresult;
45984 }
45985
45986
45987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
45988   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
45989   float arg2 ;
45990
45991   arg1 = (Dali::Rect< float > *)jarg1;
45992   arg2 = (float)jarg2;
45993   if (arg1) (arg1)->top = arg2;
45994 }
45995
45996
45997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
45998   float jresult ;
45999   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46000   float result;
46001
46002   arg1 = (Dali::Rect< float > *)jarg1;
46003   result = (float) ((arg1)->top);
46004   jresult = result;
46005   return jresult;
46006 }
46007
46008
46009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46010   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46011
46012   arg1 = (Dali::Rect< float > *)jarg1;
46013   {
46014     try {
46015       delete arg1;
46016     } catch (std::out_of_range& e) {
46017       {
46018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46019       };
46020     } catch (std::exception& e) {
46021       {
46022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46023       };
46024     } catch (...) {
46025       {
46026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46027       };
46028     }
46029   }
46030 }
46031
46032
46033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46034   int jresult ;
46035   int result;
46036
46037   result = (int)Dali::Vector< int >::BaseType;
46038   jresult = (int)result;
46039   return jresult;
46040 }
46041
46042
46043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46044   void * jresult ;
46045   Dali::Vector< int > *result = 0 ;
46046
46047   {
46048     try {
46049       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46050     } catch (std::out_of_range& e) {
46051       {
46052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46053       };
46054     } catch (std::exception& e) {
46055       {
46056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46057       };
46058     } catch (...) {
46059       {
46060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46061       };
46062     }
46063   }
46064   jresult = (void *)result;
46065   return jresult;
46066 }
46067
46068
46069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46070   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46071
46072   arg1 = (Dali::Vector< int > *)jarg1;
46073   {
46074     try {
46075       delete arg1;
46076     } catch (std::out_of_range& e) {
46077       {
46078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46079       };
46080     } catch (std::exception& e) {
46081       {
46082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46083       };
46084     } catch (...) {
46085       {
46086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46087       };
46088     }
46089   }
46090 }
46091
46092
46093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46094   void * jresult ;
46095   Dali::Vector< int > *arg1 = 0 ;
46096   Dali::Vector< int > *result = 0 ;
46097
46098   arg1 = (Dali::Vector< int > *)jarg1;
46099   if (!arg1) {
46100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46101     return 0;
46102   }
46103   {
46104     try {
46105       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46106     } catch (std::out_of_range& e) {
46107       {
46108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46109       };
46110     } catch (std::exception& e) {
46111       {
46112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46113       };
46114     } catch (...) {
46115       {
46116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46117       };
46118     }
46119   }
46120   jresult = (void *)result;
46121   return jresult;
46122 }
46123
46124
46125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46126   void * jresult ;
46127   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46128   Dali::Vector< int > *arg2 = 0 ;
46129   Dali::Vector< int > *result = 0 ;
46130
46131   arg1 = (Dali::Vector< int > *)jarg1;
46132   arg2 = (Dali::Vector< int > *)jarg2;
46133   if (!arg2) {
46134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46135     return 0;
46136   }
46137   {
46138     try {
46139       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46140     } catch (std::out_of_range& e) {
46141       {
46142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46143       };
46144     } catch (std::exception& e) {
46145       {
46146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46147       };
46148     } catch (...) {
46149       {
46150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46151       };
46152     }
46153   }
46154   jresult = (void *)result;
46155   return jresult;
46156 }
46157
46158
46159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46160   void * jresult ;
46161   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46162   Dali::Vector< int >::Iterator result;
46163
46164   arg1 = (Dali::Vector< int > *)jarg1;
46165   {
46166     try {
46167       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46168     } catch (std::out_of_range& e) {
46169       {
46170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46171       };
46172     } catch (std::exception& e) {
46173       {
46174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46175       };
46176     } catch (...) {
46177       {
46178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46179       };
46180     }
46181   }
46182   jresult = (void *)result;
46183   return jresult;
46184 }
46185
46186
46187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46188   void * jresult ;
46189   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46190   Dali::Vector< int >::Iterator result;
46191
46192   arg1 = (Dali::Vector< int > *)jarg1;
46193   {
46194     try {
46195       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46196     } catch (std::out_of_range& e) {
46197       {
46198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46199       };
46200     } catch (std::exception& e) {
46201       {
46202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46203       };
46204     } catch (...) {
46205       {
46206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46207       };
46208     }
46209   }
46210   jresult = (void *)result;
46211   return jresult;
46212 }
46213
46214
46215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46216   void * jresult ;
46217   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46218   Dali::Vector< int >::SizeType arg2 ;
46219   Dali::Vector< int >::ItemType *result = 0 ;
46220
46221   arg1 = (Dali::Vector< int > *)jarg1;
46222   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46223   {
46224     try {
46225       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46226     } catch (std::out_of_range& e) {
46227       {
46228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46229       };
46230     } catch (std::exception& e) {
46231       {
46232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46233       };
46234     } catch (...) {
46235       {
46236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46237       };
46238     }
46239   }
46240   jresult = (void *)result;
46241   return jresult;
46242 }
46243
46244
46245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46246   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46247   Dali::Vector< int >::ItemType *arg2 = 0 ;
46248   Dali::Vector< int >::ItemType temp2 ;
46249
46250   arg1 = (Dali::Vector< int > *)jarg1;
46251   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46252   arg2 = &temp2;
46253   {
46254     try {
46255       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46256     } catch (std::out_of_range& e) {
46257       {
46258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46259       };
46260     } catch (std::exception& e) {
46261       {
46262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46263       };
46264     } catch (...) {
46265       {
46266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46267       };
46268     }
46269   }
46270 }
46271
46272
46273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46274   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46275   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46276   Dali::Vector< int >::ItemType *arg3 = 0 ;
46277   Dali::Vector< int >::ItemType temp3 ;
46278
46279   arg1 = (Dali::Vector< int > *)jarg1;
46280   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46281   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46282   arg3 = &temp3;
46283   {
46284     try {
46285       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46286     } catch (std::out_of_range& e) {
46287       {
46288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46289       };
46290     } catch (std::exception& e) {
46291       {
46292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46293       };
46294     } catch (...) {
46295       {
46296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46297       };
46298     }
46299   }
46300 }
46301
46302
46303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46304   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46305   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46306   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46307   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46308
46309   arg1 = (Dali::Vector< int > *)jarg1;
46310   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46311   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46312   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46313   {
46314     try {
46315       (arg1)->Insert(arg2,arg3,arg4);
46316     } catch (std::out_of_range& e) {
46317       {
46318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46319       };
46320     } catch (std::exception& e) {
46321       {
46322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46323       };
46324     } catch (...) {
46325       {
46326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46327       };
46328     }
46329   }
46330 }
46331
46332
46333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46334   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46335   Dali::Vector< int >::SizeType arg2 ;
46336
46337   arg1 = (Dali::Vector< int > *)jarg1;
46338   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46339   {
46340     try {
46341       (arg1)->Reserve(arg2);
46342     } catch (std::out_of_range& e) {
46343       {
46344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46345       };
46346     } catch (std::exception& e) {
46347       {
46348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46349       };
46350     } catch (...) {
46351       {
46352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46353       };
46354     }
46355   }
46356 }
46357
46358
46359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46360   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46361   Dali::Vector< int >::SizeType arg2 ;
46362
46363   arg1 = (Dali::Vector< int > *)jarg1;
46364   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46365   {
46366     try {
46367       (arg1)->Resize(arg2);
46368     } catch (std::out_of_range& e) {
46369       {
46370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46371       };
46372     } catch (std::exception& e) {
46373       {
46374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46375       };
46376     } catch (...) {
46377       {
46378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46379       };
46380     }
46381   }
46382 }
46383
46384
46385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46386   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46387   Dali::Vector< int >::SizeType arg2 ;
46388   Dali::Vector< int >::ItemType *arg3 = 0 ;
46389   Dali::Vector< int >::ItemType temp3 ;
46390
46391   arg1 = (Dali::Vector< int > *)jarg1;
46392   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46393   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46394   arg3 = &temp3;
46395   {
46396     try {
46397       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46398     } catch (std::out_of_range& e) {
46399       {
46400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46401       };
46402     } catch (std::exception& e) {
46403       {
46404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46405       };
46406     } catch (...) {
46407       {
46408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46409       };
46410     }
46411   }
46412 }
46413
46414
46415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46416   void * jresult ;
46417   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46418   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46419   Dali::Vector< int >::Iterator result;
46420
46421   arg1 = (Dali::Vector< int > *)jarg1;
46422   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46423   {
46424     try {
46425       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46426     } catch (std::out_of_range& e) {
46427       {
46428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46429       };
46430     } catch (std::exception& e) {
46431       {
46432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46433       };
46434     } catch (...) {
46435       {
46436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46437       };
46438     }
46439   }
46440   jresult = (void *)result;
46441   return jresult;
46442 }
46443
46444
46445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46446   void * jresult ;
46447   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46448   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46449   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46450   Dali::Vector< int >::Iterator result;
46451
46452   arg1 = (Dali::Vector< int > *)jarg1;
46453   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46454   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46455   {
46456     try {
46457       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46458     } catch (std::out_of_range& e) {
46459       {
46460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46461       };
46462     } catch (std::exception& e) {
46463       {
46464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46465       };
46466     } catch (...) {
46467       {
46468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46469       };
46470     }
46471   }
46472   jresult = (void *)result;
46473   return jresult;
46474 }
46475
46476
46477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46478   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46479   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46480
46481   arg1 = (Dali::Vector< int > *)jarg1;
46482   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46483   {
46484     try {
46485       (arg1)->Remove(arg2);
46486     } catch (std::out_of_range& e) {
46487       {
46488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46489       };
46490     } catch (std::exception& e) {
46491       {
46492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46493       };
46494     } catch (...) {
46495       {
46496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46497       };
46498     }
46499   }
46500 }
46501
46502
46503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46504   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46505   Dali::Vector< int > *arg2 = 0 ;
46506
46507   arg1 = (Dali::Vector< int > *)jarg1;
46508   arg2 = (Dali::Vector< int > *)jarg2;
46509   if (!arg2) {
46510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
46511     return ;
46512   }
46513   {
46514     try {
46515       (arg1)->Swap(*arg2);
46516     } catch (std::out_of_range& e) {
46517       {
46518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46519       };
46520     } catch (std::exception& e) {
46521       {
46522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46523       };
46524     } catch (...) {
46525       {
46526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46527       };
46528     }
46529   }
46530 }
46531
46532
46533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
46534   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46535
46536   arg1 = (Dali::Vector< int > *)jarg1;
46537   {
46538     try {
46539       (arg1)->Clear();
46540     } catch (std::out_of_range& e) {
46541       {
46542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46543       };
46544     } catch (std::exception& e) {
46545       {
46546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46547       };
46548     } catch (...) {
46549       {
46550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46551       };
46552     }
46553   }
46554 }
46555
46556
46557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
46558   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46559
46560   arg1 = (Dali::Vector< int > *)jarg1;
46561   {
46562     try {
46563       (arg1)->Release();
46564     } catch (std::out_of_range& e) {
46565       {
46566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46567       };
46568     } catch (std::exception& e) {
46569       {
46570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46571       };
46572     } catch (...) {
46573       {
46574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46575       };
46576     }
46577   }
46578 }
46579
46580
46581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
46582   int jresult ;
46583   int result;
46584
46585   result = (int)Dali::Vector< float >::BaseType;
46586   jresult = (int)result;
46587   return jresult;
46588 }
46589
46590
46591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
46592   void * jresult ;
46593   Dali::Vector< float > *result = 0 ;
46594
46595   {
46596     try {
46597       result = (Dali::Vector< float > *)new Dali::Vector< float >();
46598     } catch (std::out_of_range& e) {
46599       {
46600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46601       };
46602     } catch (std::exception& e) {
46603       {
46604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46605       };
46606     } catch (...) {
46607       {
46608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46609       };
46610     }
46611   }
46612   jresult = (void *)result;
46613   return jresult;
46614 }
46615
46616
46617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
46618   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46619
46620   arg1 = (Dali::Vector< float > *)jarg1;
46621   {
46622     try {
46623       delete arg1;
46624     } catch (std::out_of_range& e) {
46625       {
46626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46627       };
46628     } catch (std::exception& e) {
46629       {
46630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46631       };
46632     } catch (...) {
46633       {
46634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46635       };
46636     }
46637   }
46638 }
46639
46640
46641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
46642   void * jresult ;
46643   Dali::Vector< float > *arg1 = 0 ;
46644   Dali::Vector< float > *result = 0 ;
46645
46646   arg1 = (Dali::Vector< float > *)jarg1;
46647   if (!arg1) {
46648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46649     return 0;
46650   }
46651   {
46652     try {
46653       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
46654     } catch (std::out_of_range& e) {
46655       {
46656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46657       };
46658     } catch (std::exception& e) {
46659       {
46660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46661       };
46662     } catch (...) {
46663       {
46664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46665       };
46666     }
46667   }
46668   jresult = (void *)result;
46669   return jresult;
46670 }
46671
46672
46673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
46674   void * jresult ;
46675   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46676   Dali::Vector< float > *arg2 = 0 ;
46677   Dali::Vector< float > *result = 0 ;
46678
46679   arg1 = (Dali::Vector< float > *)jarg1;
46680   arg2 = (Dali::Vector< float > *)jarg2;
46681   if (!arg2) {
46682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46683     return 0;
46684   }
46685   {
46686     try {
46687       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
46688     } catch (std::out_of_range& e) {
46689       {
46690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46691       };
46692     } catch (std::exception& e) {
46693       {
46694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46695       };
46696     } catch (...) {
46697       {
46698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46699       };
46700     }
46701   }
46702   jresult = (void *)result;
46703   return jresult;
46704 }
46705
46706
46707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
46708   void * jresult ;
46709   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46710   Dali::Vector< float >::Iterator result;
46711
46712   arg1 = (Dali::Vector< float > *)jarg1;
46713   {
46714     try {
46715       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
46716     } catch (std::out_of_range& e) {
46717       {
46718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46719       };
46720     } catch (std::exception& e) {
46721       {
46722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46723       };
46724     } catch (...) {
46725       {
46726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46727       };
46728     }
46729   }
46730   jresult = (void *)result;
46731   return jresult;
46732 }
46733
46734
46735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
46736   void * jresult ;
46737   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46738   Dali::Vector< float >::Iterator result;
46739
46740   arg1 = (Dali::Vector< float > *)jarg1;
46741   {
46742     try {
46743       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
46744     } catch (std::out_of_range& e) {
46745       {
46746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46747       };
46748     } catch (std::exception& e) {
46749       {
46750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46751       };
46752     } catch (...) {
46753       {
46754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46755       };
46756     }
46757   }
46758   jresult = (void *)result;
46759   return jresult;
46760 }
46761
46762
46763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46764   void * jresult ;
46765   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46766   Dali::Vector< float >::SizeType arg2 ;
46767   Dali::Vector< float >::ItemType *result = 0 ;
46768
46769   arg1 = (Dali::Vector< float > *)jarg1;
46770   arg2 = (Dali::Vector< float >::SizeType)jarg2;
46771   {
46772     try {
46773       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
46774     } catch (std::out_of_range& e) {
46775       {
46776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46777       };
46778     } catch (std::exception& e) {
46779       {
46780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46781       };
46782     } catch (...) {
46783       {
46784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46785       };
46786     }
46787   }
46788   jresult = (void *)result;
46789   return jresult;
46790 }
46791
46792
46793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
46794   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46795   Dali::Vector< float >::ItemType *arg2 = 0 ;
46796   Dali::Vector< float >::ItemType temp2 ;
46797
46798   arg1 = (Dali::Vector< float > *)jarg1;
46799   temp2 = (Dali::Vector< float >::ItemType)jarg2;
46800   arg2 = &temp2;
46801   {
46802     try {
46803       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
46804     } catch (std::out_of_range& e) {
46805       {
46806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46807       };
46808     } catch (std::exception& e) {
46809       {
46810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46811       };
46812     } catch (...) {
46813       {
46814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46815       };
46816     }
46817   }
46818 }
46819
46820
46821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
46822   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46823   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
46824   Dali::Vector< float >::ItemType *arg3 = 0 ;
46825   Dali::Vector< float >::ItemType temp3 ;
46826
46827   arg1 = (Dali::Vector< float > *)jarg1;
46828   arg2 = (Dali::Vector< float >::Iterator)jarg2;
46829   temp3 = (Dali::Vector< float >::ItemType)jarg3;
46830   arg3 = &temp3;
46831   {
46832     try {
46833       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
46834     } catch (std::out_of_range& e) {
46835       {
46836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46837       };
46838     } catch (std::exception& e) {
46839       {
46840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46841       };
46842     } catch (...) {
46843       {
46844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46845       };
46846     }
46847   }
46848 }
46849
46850
46851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46852   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46853   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
46854   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
46855   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
46856
46857   arg1 = (Dali::Vector< float > *)jarg1;
46858   arg2 = (Dali::Vector< float >::Iterator)jarg2;
46859   arg3 = (Dali::Vector< float >::Iterator)jarg3;
46860   arg4 = (Dali::Vector< float >::Iterator)jarg4;
46861   {
46862     try {
46863       (arg1)->Insert(arg2,arg3,arg4);
46864     } catch (std::out_of_range& e) {
46865       {
46866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46867       };
46868     } catch (std::exception& e) {
46869       {
46870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46871       };
46872     } catch (...) {
46873       {
46874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46875       };
46876     }
46877   }
46878 }
46879
46880
46881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
46882   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46883   Dali::Vector< float >::SizeType arg2 ;
46884
46885   arg1 = (Dali::Vector< float > *)jarg1;
46886   arg2 = (Dali::Vector< float >::SizeType)jarg2;
46887   {
46888     try {
46889       (arg1)->Reserve(arg2);
46890     } catch (std::out_of_range& e) {
46891       {
46892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46893       };
46894     } catch (std::exception& e) {
46895       {
46896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46897       };
46898     } catch (...) {
46899       {
46900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46901       };
46902     }
46903   }
46904 }
46905
46906
46907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46908   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46909   Dali::Vector< float >::SizeType arg2 ;
46910
46911   arg1 = (Dali::Vector< float > *)jarg1;
46912   arg2 = (Dali::Vector< float >::SizeType)jarg2;
46913   {
46914     try {
46915       (arg1)->Resize(arg2);
46916     } catch (std::out_of_range& e) {
46917       {
46918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46919       };
46920     } catch (std::exception& e) {
46921       {
46922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46923       };
46924     } catch (...) {
46925       {
46926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46927       };
46928     }
46929   }
46930 }
46931
46932
46933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
46934   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46935   Dali::Vector< float >::SizeType arg2 ;
46936   Dali::Vector< float >::ItemType *arg3 = 0 ;
46937   Dali::Vector< float >::ItemType temp3 ;
46938
46939   arg1 = (Dali::Vector< float > *)jarg1;
46940   arg2 = (Dali::Vector< float >::SizeType)jarg2;
46941   temp3 = (Dali::Vector< float >::ItemType)jarg3;
46942   arg3 = &temp3;
46943   {
46944     try {
46945       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
46946     } catch (std::out_of_range& e) {
46947       {
46948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46949       };
46950     } catch (std::exception& e) {
46951       {
46952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46953       };
46954     } catch (...) {
46955       {
46956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46957       };
46958     }
46959   }
46960 }
46961
46962
46963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
46964   void * jresult ;
46965   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46966   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
46967   Dali::Vector< float >::Iterator result;
46968
46969   arg1 = (Dali::Vector< float > *)jarg1;
46970   arg2 = (Dali::Vector< float >::Iterator)jarg2;
46971   {
46972     try {
46973       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
46974     } catch (std::out_of_range& e) {
46975       {
46976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46977       };
46978     } catch (std::exception& e) {
46979       {
46980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46981       };
46982     } catch (...) {
46983       {
46984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46985       };
46986     }
46987   }
46988   jresult = (void *)result;
46989   return jresult;
46990 }
46991
46992
46993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46994   void * jresult ;
46995   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46996   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
46997   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
46998   Dali::Vector< float >::Iterator result;
46999
47000   arg1 = (Dali::Vector< float > *)jarg1;
47001   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47002   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47003   {
47004     try {
47005       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47006     } catch (std::out_of_range& e) {
47007       {
47008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47009       };
47010     } catch (std::exception& e) {
47011       {
47012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47013       };
47014     } catch (...) {
47015       {
47016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47017       };
47018     }
47019   }
47020   jresult = (void *)result;
47021   return jresult;
47022 }
47023
47024
47025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47026   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47027   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47028
47029   arg1 = (Dali::Vector< float > *)jarg1;
47030   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47031   {
47032     try {
47033       (arg1)->Remove(arg2);
47034     } catch (std::out_of_range& e) {
47035       {
47036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47037       };
47038     } catch (std::exception& e) {
47039       {
47040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47041       };
47042     } catch (...) {
47043       {
47044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47045       };
47046     }
47047   }
47048 }
47049
47050
47051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47052   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47053   Dali::Vector< float > *arg2 = 0 ;
47054
47055   arg1 = (Dali::Vector< float > *)jarg1;
47056   arg2 = (Dali::Vector< float > *)jarg2;
47057   if (!arg2) {
47058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47059     return ;
47060   }
47061   {
47062     try {
47063       (arg1)->Swap(*arg2);
47064     } catch (std::out_of_range& e) {
47065       {
47066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47067       };
47068     } catch (std::exception& e) {
47069       {
47070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47071       };
47072     } catch (...) {
47073       {
47074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47075       };
47076     }
47077   }
47078 }
47079
47080
47081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47082   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47083
47084   arg1 = (Dali::Vector< float > *)jarg1;
47085   {
47086     try {
47087       (arg1)->Clear();
47088     } catch (std::out_of_range& e) {
47089       {
47090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47091       };
47092     } catch (std::exception& e) {
47093       {
47094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47095       };
47096     } catch (...) {
47097       {
47098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47099       };
47100     }
47101   }
47102 }
47103
47104
47105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47106   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47107
47108   arg1 = (Dali::Vector< float > *)jarg1;
47109   {
47110     try {
47111       (arg1)->Release();
47112     } catch (std::out_of_range& e) {
47113       {
47114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47115       };
47116     } catch (std::exception& e) {
47117       {
47118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47119       };
47120     } catch (...) {
47121       {
47122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47123       };
47124     }
47125   }
47126 }
47127
47128
47129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47130   int jresult ;
47131   int result;
47132
47133   result = (int)Dali::Vector< unsigned char >::BaseType;
47134   jresult = (int)result;
47135   return jresult;
47136 }
47137
47138
47139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47140   void * jresult ;
47141   Dali::Vector< unsigned char > *result = 0 ;
47142
47143   {
47144     try {
47145       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47146     } catch (std::out_of_range& e) {
47147       {
47148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47149       };
47150     } catch (std::exception& e) {
47151       {
47152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47153       };
47154     } catch (...) {
47155       {
47156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47157       };
47158     }
47159   }
47160   jresult = (void *)result;
47161   return jresult;
47162 }
47163
47164
47165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47166   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47167
47168   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47169   {
47170     try {
47171       delete arg1;
47172     } catch (std::out_of_range& e) {
47173       {
47174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47175       };
47176     } catch (std::exception& e) {
47177       {
47178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47179       };
47180     } catch (...) {
47181       {
47182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47183       };
47184     }
47185   }
47186 }
47187
47188
47189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47190   void * jresult ;
47191   Dali::Vector< unsigned char > *arg1 = 0 ;
47192   Dali::Vector< unsigned char > *result = 0 ;
47193
47194   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47195   if (!arg1) {
47196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47197     return 0;
47198   }
47199   {
47200     try {
47201       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47202     } catch (std::out_of_range& e) {
47203       {
47204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47205       };
47206     } catch (std::exception& e) {
47207       {
47208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47209       };
47210     } catch (...) {
47211       {
47212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47213       };
47214     }
47215   }
47216   jresult = (void *)result;
47217   return jresult;
47218 }
47219
47220
47221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47222   void * jresult ;
47223   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47224   Dali::Vector< unsigned char > *arg2 = 0 ;
47225   Dali::Vector< unsigned char > *result = 0 ;
47226
47227   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47228   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47229   if (!arg2) {
47230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47231     return 0;
47232   }
47233   {
47234     try {
47235       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47236     } catch (std::out_of_range& e) {
47237       {
47238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47239       };
47240     } catch (std::exception& e) {
47241       {
47242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47243       };
47244     } catch (...) {
47245       {
47246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47247       };
47248     }
47249   }
47250   jresult = (void *)result;
47251   return jresult;
47252 }
47253
47254
47255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47256   void * jresult ;
47257   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47258   Dali::Vector< unsigned char >::Iterator result;
47259
47260   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47261   {
47262     try {
47263       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47264     } catch (std::out_of_range& e) {
47265       {
47266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47267       };
47268     } catch (std::exception& e) {
47269       {
47270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47271       };
47272     } catch (...) {
47273       {
47274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47275       };
47276     }
47277   }
47278   jresult = (void *)result;
47279   return jresult;
47280 }
47281
47282
47283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47284   void * jresult ;
47285   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47286   Dali::Vector< unsigned char >::Iterator result;
47287
47288   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47289   {
47290     try {
47291       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47292     } catch (std::out_of_range& e) {
47293       {
47294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47295       };
47296     } catch (std::exception& e) {
47297       {
47298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47299       };
47300     } catch (...) {
47301       {
47302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47303       };
47304     }
47305   }
47306   jresult = (void *)result;
47307   return jresult;
47308 }
47309
47310
47311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47312   void * jresult ;
47313   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47314   Dali::Vector< unsigned char >::SizeType arg2 ;
47315   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47316
47317   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47318   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47319   {
47320     try {
47321       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47322     } catch (std::out_of_range& e) {
47323       {
47324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47325       };
47326     } catch (std::exception& e) {
47327       {
47328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47329       };
47330     } catch (...) {
47331       {
47332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47333       };
47334     }
47335   }
47336   jresult = (void *)result;
47337   return jresult;
47338 }
47339
47340
47341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47342   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47343   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47344   Dali::Vector< unsigned char >::ItemType temp2 ;
47345
47346   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47347   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47348   arg2 = &temp2;
47349   {
47350     try {
47351       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47352     } catch (std::out_of_range& e) {
47353       {
47354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47355       };
47356     } catch (std::exception& e) {
47357       {
47358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47359       };
47360     } catch (...) {
47361       {
47362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47363       };
47364     }
47365   }
47366 }
47367
47368
47369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47370   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47371   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47372   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47373   Dali::Vector< unsigned char >::ItemType temp3 ;
47374
47375   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47376   arg2 = jarg2;
47377   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47378   arg3 = &temp3;
47379   {
47380     try {
47381       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47382     } catch (std::out_of_range& e) {
47383       {
47384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47385       };
47386     } catch (std::exception& e) {
47387       {
47388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47389       };
47390     } catch (...) {
47391       {
47392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47393       };
47394     }
47395   }
47396
47397
47398 }
47399
47400
47401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47402   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47403   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47404   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47405   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47406
47407   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47408   arg2 = jarg2;
47409   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47410   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47411   {
47412     try {
47413       (arg1)->Insert(arg2,arg3,arg4);
47414     } catch (std::out_of_range& e) {
47415       {
47416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47417       };
47418     } catch (std::exception& e) {
47419       {
47420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47421       };
47422     } catch (...) {
47423       {
47424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47425       };
47426     }
47427   }
47428
47429
47430 }
47431
47432
47433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47434   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47435   Dali::Vector< unsigned char >::SizeType arg2 ;
47436
47437   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47438   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47439   {
47440     try {
47441       (arg1)->Reserve(arg2);
47442     } catch (std::out_of_range& e) {
47443       {
47444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47445       };
47446     } catch (std::exception& e) {
47447       {
47448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47449       };
47450     } catch (...) {
47451       {
47452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47453       };
47454     }
47455   }
47456 }
47457
47458
47459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47460   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47461   Dali::Vector< unsigned char >::SizeType arg2 ;
47462
47463   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47464   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47465   {
47466     try {
47467       (arg1)->Resize(arg2);
47468     } catch (std::out_of_range& e) {
47469       {
47470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47471       };
47472     } catch (std::exception& e) {
47473       {
47474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47475       };
47476     } catch (...) {
47477       {
47478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47479       };
47480     }
47481   }
47482 }
47483
47484
47485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47486   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47487   Dali::Vector< unsigned char >::SizeType arg2 ;
47488   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47489   Dali::Vector< unsigned char >::ItemType temp3 ;
47490
47491   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47492   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47493   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47494   arg3 = &temp3;
47495   {
47496     try {
47497       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47498     } catch (std::out_of_range& e) {
47499       {
47500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47501       };
47502     } catch (std::exception& e) {
47503       {
47504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47505       };
47506     } catch (...) {
47507       {
47508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47509       };
47510     }
47511   }
47512 }
47513
47514
47515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
47516   void * jresult ;
47517   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47518   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47519   Dali::Vector< unsigned char >::Iterator result;
47520
47521   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47522   arg2 = jarg2;
47523   {
47524     try {
47525       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
47526     } catch (std::out_of_range& e) {
47527       {
47528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47529       };
47530     } catch (std::exception& e) {
47531       {
47532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47533       };
47534     } catch (...) {
47535       {
47536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47537       };
47538     }
47539   }
47540   jresult = (void *)result;
47541
47542
47543   return jresult;
47544 }
47545
47546
47547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
47548   void * jresult ;
47549   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47550   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47551   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47552   Dali::Vector< unsigned char >::Iterator result;
47553
47554   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47555   arg2 = jarg2;
47556   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47557   {
47558     try {
47559       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
47560     } catch (std::out_of_range& e) {
47561       {
47562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47563       };
47564     } catch (std::exception& e) {
47565       {
47566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47567       };
47568     } catch (...) {
47569       {
47570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47571       };
47572     }
47573   }
47574   jresult = (void *)result;
47575
47576
47577   return jresult;
47578 }
47579
47580
47581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
47582   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47583   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47584
47585   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47586   arg2 = jarg2;
47587   {
47588     try {
47589       (arg1)->Remove(arg2);
47590     } catch (std::out_of_range& e) {
47591       {
47592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47593       };
47594     } catch (std::exception& e) {
47595       {
47596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47597       };
47598     } catch (...) {
47599       {
47600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47601       };
47602     }
47603   }
47604
47605
47606 }
47607
47608
47609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
47610   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47611   Dali::Vector< unsigned char > *arg2 = 0 ;
47612
47613   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47614   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47615   if (!arg2) {
47616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
47617     return ;
47618   }
47619   {
47620     try {
47621       (arg1)->Swap(*arg2);
47622     } catch (std::out_of_range& e) {
47623       {
47624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47625       };
47626     } catch (std::exception& e) {
47627       {
47628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47629       };
47630     } catch (...) {
47631       {
47632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47633       };
47634     }
47635   }
47636 }
47637
47638
47639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
47640   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47641
47642   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47643   {
47644     try {
47645       (arg1)->Clear();
47646     } catch (std::out_of_range& e) {
47647       {
47648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47649       };
47650     } catch (std::exception& e) {
47651       {
47652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47653       };
47654     } catch (...) {
47655       {
47656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47657       };
47658     }
47659   }
47660 }
47661
47662
47663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
47664   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47665
47666   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47667   {
47668     try {
47669       (arg1)->Release();
47670     } catch (std::out_of_range& e) {
47671       {
47672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47673       };
47674     } catch (std::exception& e) {
47675       {
47676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47677       };
47678     } catch (...) {
47679       {
47680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47681       };
47682     }
47683   }
47684 }
47685
47686
47687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
47688   int jresult ;
47689   int result;
47690
47691   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
47692   jresult = (int)result;
47693   return jresult;
47694 }
47695
47696
47697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
47698   void * jresult ;
47699   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
47700
47701   {
47702     try {
47703       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
47704     } catch (std::out_of_range& e) {
47705       {
47706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47707       };
47708     } catch (std::exception& e) {
47709       {
47710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47711       };
47712     } catch (...) {
47713       {
47714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47715       };
47716     }
47717   }
47718   jresult = (void *)result;
47719   return jresult;
47720 }
47721
47722
47723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
47724   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47725
47726   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47727   {
47728     try {
47729       delete arg1;
47730     } catch (std::out_of_range& e) {
47731       {
47732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47733       };
47734     } catch (std::exception& e) {
47735       {
47736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47737       };
47738     } catch (...) {
47739       {
47740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47741       };
47742     }
47743   }
47744 }
47745
47746
47747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
47748   void * jresult ;
47749   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
47750   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
47751
47752   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47753   if (!arg1) {
47754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
47755     return 0;
47756   }
47757   {
47758     try {
47759       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
47760     } catch (std::out_of_range& e) {
47761       {
47762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47763       };
47764     } catch (std::exception& e) {
47765       {
47766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47767       };
47768     } catch (...) {
47769       {
47770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47771       };
47772     }
47773   }
47774   jresult = (void *)result;
47775   return jresult;
47776 }
47777
47778
47779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
47780   void * jresult ;
47781   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47782   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
47783   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
47784
47785   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47786   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
47787   if (!arg2) {
47788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
47789     return 0;
47790   }
47791   {
47792     try {
47793       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
47794     } catch (std::out_of_range& e) {
47795       {
47796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47797       };
47798     } catch (std::exception& e) {
47799       {
47800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47801       };
47802     } catch (...) {
47803       {
47804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47805       };
47806     }
47807   }
47808   jresult = (void *)result;
47809   return jresult;
47810 }
47811
47812
47813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
47814   void * jresult ;
47815   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47816   Dali::Vector< Dali::Uint16Pair >::Iterator result;
47817
47818   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47819   {
47820     try {
47821       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
47822     } catch (std::out_of_range& e) {
47823       {
47824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47825       };
47826     } catch (std::exception& e) {
47827       {
47828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47829       };
47830     } catch (...) {
47831       {
47832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47833       };
47834     }
47835   }
47836   jresult = (void *)result;
47837   return jresult;
47838 }
47839
47840
47841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
47842   void * jresult ;
47843   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47844   Dali::Vector< Dali::Uint16Pair >::Iterator result;
47845
47846   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47847   {
47848     try {
47849       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
47850     } catch (std::out_of_range& e) {
47851       {
47852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47853       };
47854     } catch (std::exception& e) {
47855       {
47856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47857       };
47858     } catch (...) {
47859       {
47860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47861       };
47862     }
47863   }
47864   jresult = (void *)result;
47865   return jresult;
47866 }
47867
47868
47869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47870   void * jresult ;
47871   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47872   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
47873   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
47874
47875   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47876   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
47877   {
47878     try {
47879       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
47880     } catch (std::out_of_range& e) {
47881       {
47882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47883       };
47884     } catch (std::exception& e) {
47885       {
47886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47887       };
47888     } catch (...) {
47889       {
47890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47891       };
47892     }
47893   }
47894   jresult = (void *)result;
47895   return jresult;
47896 }
47897
47898
47899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
47900   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47901   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
47902
47903   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47904   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
47905   if (!arg2) {
47906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
47907     return ;
47908   }
47909   {
47910     try {
47911       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
47912     } catch (std::out_of_range& e) {
47913       {
47914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47915       };
47916     } catch (std::exception& e) {
47917       {
47918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47919       };
47920     } catch (...) {
47921       {
47922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47923       };
47924     }
47925   }
47926 }
47927
47928
47929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
47930   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47931   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
47932   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
47933
47934   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47935   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
47936   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
47937   if (!arg3) {
47938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
47939     return ;
47940   }
47941   {
47942     try {
47943       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
47944     } catch (std::out_of_range& e) {
47945       {
47946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47947       };
47948     } catch (std::exception& e) {
47949       {
47950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47951       };
47952     } catch (...) {
47953       {
47954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47955       };
47956     }
47957   }
47958 }
47959
47960
47961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47962   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47963   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
47964   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
47965   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
47966
47967   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47968   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
47969   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
47970   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
47971   {
47972     try {
47973       (arg1)->Insert(arg2,arg3,arg4);
47974     } catch (std::out_of_range& e) {
47975       {
47976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47977       };
47978     } catch (std::exception& e) {
47979       {
47980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47981       };
47982     } catch (...) {
47983       {
47984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47985       };
47986     }
47987   }
47988 }
47989
47990
47991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
47992   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47993   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
47994
47995   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47996   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
47997   {
47998     try {
47999       (arg1)->Reserve(arg2);
48000     } catch (std::out_of_range& e) {
48001       {
48002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48003       };
48004     } catch (std::exception& e) {
48005       {
48006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48007       };
48008     } catch (...) {
48009       {
48010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48011       };
48012     }
48013   }
48014 }
48015
48016
48017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48018   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48019   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48020
48021   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48022   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48023   {
48024     try {
48025       (arg1)->Resize(arg2);
48026     } catch (std::out_of_range& e) {
48027       {
48028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48029       };
48030     } catch (std::exception& e) {
48031       {
48032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48033       };
48034     } catch (...) {
48035       {
48036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48037       };
48038     }
48039   }
48040 }
48041
48042
48043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48044   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48045   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48046   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48047
48048   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48049   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48050   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48051   if (!arg3) {
48052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48053     return ;
48054   }
48055   {
48056     try {
48057       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48058     } catch (std::out_of_range& e) {
48059       {
48060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48061       };
48062     } catch (std::exception& e) {
48063       {
48064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48065       };
48066     } catch (...) {
48067       {
48068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48069       };
48070     }
48071   }
48072 }
48073
48074
48075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48076   void * jresult ;
48077   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48078   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48079   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48080
48081   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48082   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48083   {
48084     try {
48085       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48086     } catch (std::out_of_range& e) {
48087       {
48088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48089       };
48090     } catch (std::exception& e) {
48091       {
48092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48093       };
48094     } catch (...) {
48095       {
48096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48097       };
48098     }
48099   }
48100   jresult = (void *)result;
48101   return jresult;
48102 }
48103
48104
48105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48106   void * jresult ;
48107   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48108   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48109   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48110   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48111
48112   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48113   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48114   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48115   {
48116     try {
48117       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48118     } catch (std::out_of_range& e) {
48119       {
48120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48121       };
48122     } catch (std::exception& e) {
48123       {
48124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48125       };
48126     } catch (...) {
48127       {
48128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48129       };
48130     }
48131   }
48132   jresult = (void *)result;
48133   return jresult;
48134 }
48135
48136
48137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48138   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48139   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48140
48141   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48142   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48143   {
48144     try {
48145       (arg1)->Remove(arg2);
48146     } catch (std::out_of_range& e) {
48147       {
48148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48149       };
48150     } catch (std::exception& e) {
48151       {
48152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48153       };
48154     } catch (...) {
48155       {
48156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48157       };
48158     }
48159   }
48160 }
48161
48162
48163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48164   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48165   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48166
48167   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48168   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48169   if (!arg2) {
48170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48171     return ;
48172   }
48173   {
48174     try {
48175       (arg1)->Swap(*arg2);
48176     } catch (std::out_of_range& e) {
48177       {
48178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48179       };
48180     } catch (std::exception& e) {
48181       {
48182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48183       };
48184     } catch (...) {
48185       {
48186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48187       };
48188     }
48189   }
48190 }
48191
48192
48193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48194   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48195
48196   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48197   {
48198     try {
48199       (arg1)->Clear();
48200     } catch (std::out_of_range& e) {
48201       {
48202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48203       };
48204     } catch (std::exception& e) {
48205       {
48206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48207       };
48208     } catch (...) {
48209       {
48210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48211       };
48212     }
48213   }
48214 }
48215
48216
48217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48218   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48219
48220   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48221   {
48222     try {
48223       (arg1)->Release();
48224     } catch (std::out_of_range& e) {
48225       {
48226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48227       };
48228     } catch (std::exception& e) {
48229       {
48230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48231       };
48232     } catch (...) {
48233       {
48234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48235       };
48236     }
48237   }
48238 }
48239
48240
48241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48242   void * jresult ;
48243   Dali::Signal< void () > *result = 0 ;
48244
48245   {
48246     try {
48247       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48248     } catch (std::out_of_range& e) {
48249       {
48250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48251       };
48252     } catch (std::exception& e) {
48253       {
48254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48255       };
48256     } catch (...) {
48257       {
48258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48259       };
48260     }
48261   }
48262   jresult = (void *)result;
48263   return jresult;
48264 }
48265
48266
48267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48268   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48269
48270   arg1 = (Dali::Signal< void () > *)jarg1;
48271   {
48272     try {
48273       delete arg1;
48274     } catch (std::out_of_range& e) {
48275       {
48276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48277       };
48278     } catch (std::exception& e) {
48279       {
48280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48281       };
48282     } catch (...) {
48283       {
48284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48285       };
48286     }
48287   }
48288 }
48289
48290
48291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48292   unsigned int jresult ;
48293   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48294   bool result;
48295
48296   arg1 = (Dali::Signal< void () > *)jarg1;
48297   {
48298     try {
48299       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48300     } catch (std::out_of_range& e) {
48301       {
48302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48303       };
48304     } catch (std::exception& e) {
48305       {
48306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48307       };
48308     } catch (...) {
48309       {
48310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48311       };
48312     }
48313   }
48314   jresult = result;
48315   return jresult;
48316 }
48317
48318
48319 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48320   unsigned long jresult ;
48321   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48322   std::size_t result;
48323
48324   arg1 = (Dali::Signal< void () > *)jarg1;
48325   {
48326     try {
48327       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48328     } catch (std::out_of_range& e) {
48329       {
48330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48331       };
48332     } catch (std::exception& e) {
48333       {
48334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48335       };
48336     } catch (...) {
48337       {
48338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48339       };
48340     }
48341   }
48342   jresult = (unsigned long)result;
48343   return jresult;
48344 }
48345
48346
48347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48348   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48349   void (*arg2)() = (void (*)()) 0 ;
48350
48351   arg1 = (Dali::Signal< void () > *)jarg1;
48352   arg2 = (void (*)())jarg2;
48353   {
48354     try {
48355       (arg1)->Connect(arg2);
48356     } catch (std::out_of_range& e) {
48357       {
48358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48359       };
48360     } catch (std::exception& e) {
48361       {
48362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48363       };
48364     } catch (...) {
48365       {
48366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48367       };
48368     }
48369   }
48370 }
48371
48372
48373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48374   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48375   void (*arg2)() = (void (*)()) 0 ;
48376
48377   arg1 = (Dali::Signal< void () > *)jarg1;
48378   arg2 = (void (*)())jarg2;
48379   {
48380     try {
48381       (arg1)->Disconnect(arg2);
48382     } catch (std::out_of_range& e) {
48383       {
48384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48385       };
48386     } catch (std::exception& e) {
48387       {
48388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48389       };
48390     } catch (...) {
48391       {
48392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48393       };
48394     }
48395   }
48396 }
48397
48398
48399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48400   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48401   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48402   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48403
48404   arg1 = (Dali::Signal< void () > *)jarg1;
48405   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48406   arg3 = (Dali::FunctorDelegate *)jarg3;
48407   {
48408     try {
48409       (arg1)->Connect(arg2,arg3);
48410     } catch (std::out_of_range& e) {
48411       {
48412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48413       };
48414     } catch (std::exception& e) {
48415       {
48416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48417       };
48418     } catch (...) {
48419       {
48420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48421       };
48422     }
48423   }
48424 }
48425
48426
48427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48428   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48429
48430   arg1 = (Dali::Signal< void () > *)jarg1;
48431   {
48432     try {
48433       (arg1)->Emit();
48434     } catch (std::out_of_range& e) {
48435       {
48436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48437       };
48438     } catch (std::exception& e) {
48439       {
48440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48441       };
48442     } catch (...) {
48443       {
48444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48445       };
48446     }
48447   }
48448 }
48449
48450
48451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BoolSignal() {
48452   void * jresult ;
48453   Dali::Signal< bool () > *result = 0 ;
48454
48455   {
48456     try {
48457       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
48458     } catch (std::out_of_range& e) {
48459       {
48460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48461       };
48462     } catch (std::exception& e) {
48463       {
48464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48465       };
48466     } catch (...) {
48467       {
48468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48469       };
48470     }
48471   }
48472   jresult = (void *)result;
48473   return jresult;
48474 }
48475
48476
48477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BoolSignal(void * jarg1) {
48478   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48479
48480   arg1 = (Dali::Signal< bool () > *)jarg1;
48481   {
48482     try {
48483       delete arg1;
48484     } catch (std::out_of_range& e) {
48485       {
48486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48487       };
48488     } catch (std::exception& e) {
48489       {
48490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48491       };
48492     } catch (...) {
48493       {
48494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48495       };
48496     }
48497   }
48498 }
48499
48500
48501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BoolSignal_Empty(void * jarg1) {
48502   unsigned int jresult ;
48503   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48504   bool result;
48505
48506   arg1 = (Dali::Signal< bool () > *)jarg1;
48507   {
48508     try {
48509       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
48510     } catch (std::out_of_range& e) {
48511       {
48512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48513       };
48514     } catch (std::exception& e) {
48515       {
48516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48517       };
48518     } catch (...) {
48519       {
48520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48521       };
48522     }
48523   }
48524   jresult = result;
48525   return jresult;
48526 }
48527
48528
48529 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_BoolSignal_GetConnectionCount(void * jarg1) {
48530   unsigned long jresult ;
48531   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48532   std::size_t result;
48533
48534   arg1 = (Dali::Signal< bool () > *)jarg1;
48535   {
48536     try {
48537       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
48538     } catch (std::out_of_range& e) {
48539       {
48540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48541       };
48542     } catch (std::exception& e) {
48543       {
48544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48545       };
48546     } catch (...) {
48547       {
48548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48549       };
48550     }
48551   }
48552   jresult = (unsigned long)result;
48553   return jresult;
48554 }
48555
48556
48557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BoolSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48558   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48559   bool (*arg2)() = (bool (*)()) 0 ;
48560
48561   arg1 = (Dali::Signal< bool () > *)jarg1;
48562   arg2 = (bool (*)())jarg2;
48563   {
48564     try {
48565       (arg1)->Connect(arg2);
48566     } catch (std::out_of_range& e) {
48567       {
48568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48569       };
48570     } catch (std::exception& e) {
48571       {
48572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48573       };
48574     } catch (...) {
48575       {
48576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48577       };
48578     }
48579   }
48580 }
48581
48582
48583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BoolSignal_Disconnect(void * jarg1, void * jarg2) {
48584   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48585   bool (*arg2)() = (bool (*)()) 0 ;
48586
48587   arg1 = (Dali::Signal< bool () > *)jarg1;
48588   arg2 = (bool (*)())jarg2;
48589   {
48590     try {
48591       (arg1)->Disconnect(arg2);
48592     } catch (std::out_of_range& e) {
48593       {
48594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48595       };
48596     } catch (std::exception& e) {
48597       {
48598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48599       };
48600     } catch (...) {
48601       {
48602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48603       };
48604     }
48605   }
48606 }
48607
48608
48609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BoolSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48610   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48611   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48612   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48613
48614   arg1 = (Dali::Signal< bool () > *)jarg1;
48615   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48616   arg3 = (Dali::FunctorDelegate *)jarg3;
48617   {
48618     try {
48619       (arg1)->Connect(arg2,arg3);
48620     } catch (std::out_of_range& e) {
48621       {
48622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48623       };
48624     } catch (std::exception& e) {
48625       {
48626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48627       };
48628     } catch (...) {
48629       {
48630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48631       };
48632     }
48633   }
48634 }
48635
48636
48637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BoolSignal_Emit(void * jarg1) {
48638   unsigned int jresult ;
48639   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
48640   bool result;
48641
48642   arg1 = (Dali::Signal< bool () > *)jarg1;
48643   {
48644     try {
48645       result = (bool)(arg1)->Emit();
48646     } catch (std::out_of_range& e) {
48647       {
48648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48649       };
48650     } catch (std::exception& e) {
48651       {
48652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48653       };
48654     } catch (...) {
48655       {
48656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48657       };
48658     }
48659   }
48660   jresult = result;
48661   return jresult;
48662 }
48663
48664
48665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48666   unsigned int jresult ;
48667   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48668   bool result;
48669
48670   arg1 = (Dali::Signal< void (float) > *)jarg1;
48671   {
48672     try {
48673       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48674     } catch (std::out_of_range& e) {
48675       {
48676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48677       };
48678     } catch (std::exception& e) {
48679       {
48680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48681       };
48682     } catch (...) {
48683       {
48684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48685       };
48686     }
48687   }
48688   jresult = result;
48689   return jresult;
48690 }
48691
48692
48693 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48694   unsigned long jresult ;
48695   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48696   std::size_t result;
48697
48698   arg1 = (Dali::Signal< void (float) > *)jarg1;
48699   {
48700     try {
48701       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48702     } catch (std::out_of_range& e) {
48703       {
48704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48705       };
48706     } catch (std::exception& e) {
48707       {
48708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48709       };
48710     } catch (...) {
48711       {
48712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48713       };
48714     }
48715   }
48716   jresult = (unsigned long)result;
48717   return jresult;
48718 }
48719
48720
48721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
48722   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48723   void (*arg2)(float) = (void (*)(float)) 0 ;
48724
48725   arg1 = (Dali::Signal< void (float) > *)jarg1;
48726   arg2 = (void (*)(float))jarg2;
48727   {
48728     try {
48729       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
48730     } catch (std::out_of_range& e) {
48731       {
48732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48733       };
48734     } catch (std::exception& e) {
48735       {
48736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48737       };
48738     } catch (...) {
48739       {
48740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48741       };
48742     }
48743   }
48744 }
48745
48746
48747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
48748   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48749   void (*arg2)(float) = (void (*)(float)) 0 ;
48750
48751   arg1 = (Dali::Signal< void (float) > *)jarg1;
48752   arg2 = (void (*)(float))jarg2;
48753   {
48754     try {
48755       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
48756     } catch (std::out_of_range& e) {
48757       {
48758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48759       };
48760     } catch (std::exception& e) {
48761       {
48762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48763       };
48764     } catch (...) {
48765       {
48766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48767       };
48768     }
48769   }
48770 }
48771
48772
48773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
48774   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48775   float arg2 ;
48776
48777   arg1 = (Dali::Signal< void (float) > *)jarg1;
48778   arg2 = (float)jarg2;
48779   {
48780     try {
48781       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
48782     } catch (std::out_of_range& e) {
48783       {
48784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48785       };
48786     } catch (std::exception& e) {
48787       {
48788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48789       };
48790     } catch (...) {
48791       {
48792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48793       };
48794     }
48795   }
48796 }
48797
48798
48799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
48800   void * jresult ;
48801   Dali::Signal< void (float) > *result = 0 ;
48802
48803   {
48804     try {
48805       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
48806     } catch (std::out_of_range& e) {
48807       {
48808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48809       };
48810     } catch (std::exception& e) {
48811       {
48812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48813       };
48814     } catch (...) {
48815       {
48816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48817       };
48818     }
48819   }
48820   jresult = (void *)result;
48821   return jresult;
48822 }
48823
48824
48825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
48826   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48827
48828   arg1 = (Dali::Signal< void (float) > *)jarg1;
48829   {
48830     try {
48831       delete arg1;
48832     } catch (std::out_of_range& e) {
48833       {
48834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48835       };
48836     } catch (std::exception& e) {
48837       {
48838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48839       };
48840     } catch (...) {
48841       {
48842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48843       };
48844     }
48845   }
48846 }
48847
48848
48849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
48850   unsigned int jresult ;
48851   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48852   bool result;
48853
48854   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48855   {
48856     try {
48857       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48858     } catch (std::out_of_range& e) {
48859       {
48860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48861       };
48862     } catch (std::exception& e) {
48863       {
48864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48865       };
48866     } catch (...) {
48867       {
48868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48869       };
48870     }
48871   }
48872   jresult = result;
48873   return jresult;
48874 }
48875
48876
48877 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
48878   unsigned long jresult ;
48879   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48880   std::size_t result;
48881
48882   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48883   {
48884     try {
48885       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48886     } catch (std::out_of_range& e) {
48887       {
48888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48889       };
48890     } catch (std::exception& e) {
48891       {
48892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48893       };
48894     } catch (...) {
48895       {
48896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48897       };
48898     }
48899   }
48900   jresult = (unsigned long)result;
48901   return jresult;
48902 }
48903
48904
48905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
48906   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48907   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
48908
48909   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48910   arg2 = (void (*)(Dali::BaseHandle))jarg2;
48911   {
48912     try {
48913       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
48914     } catch (std::out_of_range& e) {
48915       {
48916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48917       };
48918     } catch (std::exception& e) {
48919       {
48920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48921       };
48922     } catch (...) {
48923       {
48924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48925       };
48926     }
48927   }
48928 }
48929
48930
48931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
48932   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48933   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
48934
48935   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48936   arg2 = (void (*)(Dali::BaseHandle))jarg2;
48937   {
48938     try {
48939       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
48940     } catch (std::out_of_range& e) {
48941       {
48942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48943       };
48944     } catch (std::exception& e) {
48945       {
48946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48947       };
48948     } catch (...) {
48949       {
48950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48951       };
48952     }
48953   }
48954 }
48955
48956
48957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
48958   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48959   Dali::BaseHandle arg2 ;
48960   Dali::BaseHandle *argp2 ;
48961
48962   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48963   argp2 = (Dali::BaseHandle *)jarg2;
48964   if (!argp2) {
48965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48966     return ;
48967   }
48968   arg2 = *argp2;
48969   {
48970     try {
48971       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
48972     } catch (std::out_of_range& e) {
48973       {
48974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48975       };
48976     } catch (std::exception& e) {
48977       {
48978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48979       };
48980     } catch (...) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48983       };
48984     }
48985   }
48986 }
48987
48988
48989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
48990   void * jresult ;
48991   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
48992
48993   {
48994     try {
48995       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
48996     } catch (std::out_of_range& e) {
48997       {
48998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48999       };
49000     } catch (std::exception& e) {
49001       {
49002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49003       };
49004     } catch (...) {
49005       {
49006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49007       };
49008     }
49009   }
49010   jresult = (void *)result;
49011   return jresult;
49012 }
49013
49014
49015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49016   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49017
49018   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49019   {
49020     try {
49021       delete arg1;
49022     } catch (std::out_of_range& e) {
49023       {
49024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49025       };
49026     } catch (std::exception& e) {
49027       {
49028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49029       };
49030     } catch (...) {
49031       {
49032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49033       };
49034     }
49035   }
49036 }
49037
49038
49039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49040   unsigned int jresult ;
49041   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49042   bool result;
49043
49044   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49045   {
49046     try {
49047       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49048     } catch (std::out_of_range& e) {
49049       {
49050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49051       };
49052     } catch (std::exception& e) {
49053       {
49054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49055       };
49056     } catch (...) {
49057       {
49058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49059       };
49060     }
49061   }
49062   jresult = result;
49063   return jresult;
49064 }
49065
49066
49067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49068   unsigned long jresult ;
49069   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49070   std::size_t result;
49071
49072   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49073   {
49074     try {
49075       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49076     } catch (std::out_of_range& e) {
49077       {
49078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49079       };
49080     } catch (std::exception& e) {
49081       {
49082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49083       };
49084     } catch (...) {
49085       {
49086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49087       };
49088     }
49089   }
49090   jresult = (unsigned long)result;
49091   return jresult;
49092 }
49093
49094
49095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49096   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49097   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49098
49099   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49100   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49101   {
49102     try {
49103       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49104     } catch (std::out_of_range& e) {
49105       {
49106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49107       };
49108     } catch (std::exception& e) {
49109       {
49110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49111       };
49112     } catch (...) {
49113       {
49114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49115       };
49116     }
49117   }
49118 }
49119
49120
49121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49122   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49123   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49124
49125   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49126   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49127   {
49128     try {
49129       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49130     } catch (std::out_of_range& e) {
49131       {
49132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49133       };
49134     } catch (std::exception& e) {
49135       {
49136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49137       };
49138     } catch (...) {
49139       {
49140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49141       };
49142     }
49143   }
49144 }
49145
49146
49147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49148   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49149   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49150
49151   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49152   arg2 = (Dali::RefObject *)jarg2;
49153   {
49154     try {
49155       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49156     } catch (std::out_of_range& e) {
49157       {
49158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49159       };
49160     } catch (std::exception& e) {
49161       {
49162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49163       };
49164     } catch (...) {
49165       {
49166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49167       };
49168     }
49169   }
49170 }
49171
49172
49173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49174   void * jresult ;
49175   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49176
49177   {
49178     try {
49179       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49180     } catch (std::out_of_range& e) {
49181       {
49182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49183       };
49184     } catch (std::exception& e) {
49185       {
49186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49187       };
49188     } catch (...) {
49189       {
49190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49191       };
49192     }
49193   }
49194   jresult = (void *)result;
49195   return jresult;
49196 }
49197
49198
49199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49200   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49201
49202   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49203   {
49204     try {
49205       delete arg1;
49206     } catch (std::out_of_range& e) {
49207       {
49208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49209       };
49210     } catch (std::exception& e) {
49211       {
49212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49213       };
49214     } catch (...) {
49215       {
49216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49217       };
49218     }
49219   }
49220 }
49221
49222
49223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49224   unsigned int jresult ;
49225   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49226   bool result;
49227
49228   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49229   {
49230     try {
49231       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49232     } catch (std::out_of_range& e) {
49233       {
49234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49235       };
49236     } catch (std::exception& e) {
49237       {
49238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49239       };
49240     } catch (...) {
49241       {
49242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49243       };
49244     }
49245   }
49246   jresult = result;
49247   return jresult;
49248 }
49249
49250
49251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49252   unsigned long jresult ;
49253   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49254   std::size_t result;
49255
49256   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49257   {
49258     try {
49259       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49260     } catch (std::out_of_range& e) {
49261       {
49262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49263       };
49264     } catch (std::exception& e) {
49265       {
49266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49267       };
49268     } catch (...) {
49269       {
49270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49271       };
49272     }
49273   }
49274   jresult = (unsigned long)result;
49275   return jresult;
49276 }
49277
49278
49279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49280   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49281   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49282
49283   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49284   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49285   {
49286     try {
49287       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49288     } catch (std::out_of_range& e) {
49289       {
49290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49291       };
49292     } catch (std::exception& e) {
49293       {
49294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49295       };
49296     } catch (...) {
49297       {
49298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49299       };
49300     }
49301   }
49302 }
49303
49304
49305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49306   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49307   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49308
49309   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49310   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49311   {
49312     try {
49313       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49314     } catch (std::out_of_range& e) {
49315       {
49316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49317       };
49318     } catch (std::exception& e) {
49319       {
49320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49321       };
49322     } catch (...) {
49323       {
49324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49325       };
49326     }
49327   }
49328 }
49329
49330
49331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49332   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49333   Dali::PropertyNotification *arg2 = 0 ;
49334
49335   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49336   arg2 = (Dali::PropertyNotification *)jarg2;
49337   if (!arg2) {
49338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49339     return ;
49340   }
49341   {
49342     try {
49343       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49344     } catch (std::out_of_range& e) {
49345       {
49346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49347       };
49348     } catch (std::exception& e) {
49349       {
49350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49351       };
49352     } catch (...) {
49353       {
49354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49355       };
49356     }
49357   }
49358 }
49359
49360
49361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49362   void * jresult ;
49363   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49364
49365   {
49366     try {
49367       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49368     } catch (std::out_of_range& e) {
49369       {
49370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49371       };
49372     } catch (std::exception& e) {
49373       {
49374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49375       };
49376     } catch (...) {
49377       {
49378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49379       };
49380     }
49381   }
49382   jresult = (void *)result;
49383   return jresult;
49384 }
49385
49386
49387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49388   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49389
49390   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49391   {
49392     try {
49393       delete arg1;
49394     } catch (std::out_of_range& e) {
49395       {
49396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49397       };
49398     } catch (std::exception& e) {
49399       {
49400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49401       };
49402     } catch (...) {
49403       {
49404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49405       };
49406     }
49407   }
49408 }
49409
49410
49411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49412   unsigned int jresult ;
49413   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49414   bool result;
49415
49416   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49417   {
49418     try {
49419       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49420     } catch (std::out_of_range& e) {
49421       {
49422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49423       };
49424     } catch (std::exception& e) {
49425       {
49426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49427       };
49428     } catch (...) {
49429       {
49430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49431       };
49432     }
49433   }
49434   jresult = result;
49435   return jresult;
49436 }
49437
49438
49439 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49440   unsigned long jresult ;
49441   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49442   std::size_t result;
49443
49444   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49445   {
49446     try {
49447       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49448     } catch (std::out_of_range& e) {
49449       {
49450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49451       };
49452     } catch (std::exception& e) {
49453       {
49454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49455       };
49456     } catch (...) {
49457       {
49458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49459       };
49460     }
49461   }
49462   jresult = (unsigned long)result;
49463   return jresult;
49464 }
49465
49466
49467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49468   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49469   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49470
49471   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49472   arg2 = (void (*)(Dali::Image))jarg2;
49473   {
49474     try {
49475       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49476     } catch (std::out_of_range& e) {
49477       {
49478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49479       };
49480     } catch (std::exception& e) {
49481       {
49482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49483       };
49484     } catch (...) {
49485       {
49486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49487       };
49488     }
49489   }
49490 }
49491
49492
49493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49494   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49495   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49496
49497   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49498   arg2 = (void (*)(Dali::Image))jarg2;
49499   {
49500     try {
49501       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49502     } catch (std::out_of_range& e) {
49503       {
49504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49505       };
49506     } catch (std::exception& e) {
49507       {
49508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49509       };
49510     } catch (...) {
49511       {
49512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49513       };
49514     }
49515   }
49516 }
49517
49518
49519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49520   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49521   Dali::Image arg2 ;
49522   Dali::Image *argp2 ;
49523
49524   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49525   argp2 = (Dali::Image *)jarg2;
49526   if (!argp2) {
49527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49528     return ;
49529   }
49530   arg2 = *argp2;
49531   {
49532     try {
49533       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49534     } catch (std::out_of_range& e) {
49535       {
49536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49537       };
49538     } catch (std::exception& e) {
49539       {
49540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49541       };
49542     } catch (...) {
49543       {
49544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49545       };
49546     }
49547   }
49548 }
49549
49550
49551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49552   void * jresult ;
49553   Dali::Signal< void (Dali::Image) > *result = 0 ;
49554
49555   {
49556     try {
49557       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49558     } catch (std::out_of_range& e) {
49559       {
49560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49561       };
49562     } catch (std::exception& e) {
49563       {
49564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49565       };
49566     } catch (...) {
49567       {
49568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49569       };
49570     }
49571   }
49572   jresult = (void *)result;
49573   return jresult;
49574 }
49575
49576
49577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49578   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49579
49580   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49581   {
49582     try {
49583       delete arg1;
49584     } catch (std::out_of_range& e) {
49585       {
49586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49587       };
49588     } catch (std::exception& e) {
49589       {
49590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49591       };
49592     } catch (...) {
49593       {
49594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49595       };
49596     }
49597   }
49598 }
49599
49600
49601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49602   void * jresult ;
49603   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49604
49605   {
49606     try {
49607       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49608     } catch (std::out_of_range& e) {
49609       {
49610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49611       };
49612     } catch (std::exception& e) {
49613       {
49614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49615       };
49616     } catch (...) {
49617       {
49618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49619       };
49620     }
49621   }
49622   jresult = (void *)result;
49623   return jresult;
49624 }
49625
49626
49627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49628   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49629
49630   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49631   {
49632     try {
49633       delete arg1;
49634     } catch (std::out_of_range& e) {
49635       {
49636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49637       };
49638     } catch (std::exception& e) {
49639       {
49640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49641       };
49642     } catch (...) {
49643       {
49644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49645       };
49646     }
49647   }
49648 }
49649
49650
49651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49652   unsigned int jresult ;
49653   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49654   bool result;
49655
49656   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49657   {
49658     try {
49659       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);
49660     } catch (std::out_of_range& e) {
49661       {
49662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49663       };
49664     } catch (std::exception& e) {
49665       {
49666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49667       };
49668     } catch (...) {
49669       {
49670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49671       };
49672     }
49673   }
49674   jresult = result;
49675   return jresult;
49676 }
49677
49678
49679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49680   unsigned long jresult ;
49681   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49682   std::size_t result;
49683
49684   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49685   {
49686     try {
49687       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);
49688     } catch (std::out_of_range& e) {
49689       {
49690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49691       };
49692     } catch (std::exception& e) {
49693       {
49694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49695       };
49696     } catch (...) {
49697       {
49698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49699       };
49700     }
49701   }
49702   jresult = (unsigned long)result;
49703   return jresult;
49704 }
49705
49706
49707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49708   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49709   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49710
49711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49712   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49713   {
49714     try {
49715       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49716     } catch (std::out_of_range& e) {
49717       {
49718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49719       };
49720     } catch (std::exception& e) {
49721       {
49722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49723       };
49724     } catch (...) {
49725       {
49726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49727       };
49728     }
49729   }
49730 }
49731
49732
49733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49734   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49735   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49736
49737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49738   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49739   {
49740     try {
49741       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49742     } catch (std::out_of_range& e) {
49743       {
49744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49745       };
49746     } catch (std::exception& e) {
49747       {
49748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49749       };
49750     } catch (...) {
49751       {
49752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49753       };
49754     }
49755   }
49756 }
49757
49758
49759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49760   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49761   Dali::Actor arg2 ;
49762   Dali::LongPressGesture *arg3 = 0 ;
49763   Dali::Actor *argp2 ;
49764
49765   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49766   argp2 = (Dali::Actor *)jarg2;
49767   if (!argp2) {
49768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49769     return ;
49770   }
49771   arg2 = *argp2;
49772   arg3 = (Dali::LongPressGesture *)jarg3;
49773   if (!arg3) {
49774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
49775     return ;
49776   }
49777   {
49778     try {
49779       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
49780     } catch (std::out_of_range& e) {
49781       {
49782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49783       };
49784     } catch (std::exception& e) {
49785       {
49786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49787       };
49788     } catch (...) {
49789       {
49790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49791       };
49792     }
49793   }
49794 }
49795
49796
49797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
49798   void * jresult ;
49799   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
49800
49801   {
49802     try {
49803       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
49804     } catch (std::out_of_range& e) {
49805       {
49806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49807       };
49808     } catch (std::exception& e) {
49809       {
49810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49811       };
49812     } catch (...) {
49813       {
49814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49815       };
49816     }
49817   }
49818   jresult = (void *)result;
49819   return jresult;
49820 }
49821
49822
49823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
49824   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49825
49826   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49827   {
49828     try {
49829       delete arg1;
49830     } catch (std::out_of_range& e) {
49831       {
49832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49833       };
49834     } catch (std::exception& e) {
49835       {
49836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49837       };
49838     } catch (...) {
49839       {
49840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49841       };
49842     }
49843   }
49844 }
49845
49846
49847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
49848   unsigned int jresult ;
49849   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49850   bool result;
49851
49852   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49853   {
49854     try {
49855       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);
49856     } catch (std::out_of_range& e) {
49857       {
49858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49859       };
49860     } catch (std::exception& e) {
49861       {
49862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49863       };
49864     } catch (...) {
49865       {
49866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49867       };
49868     }
49869   }
49870   jresult = result;
49871   return jresult;
49872 }
49873
49874
49875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
49876   unsigned long jresult ;
49877   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49878   std::size_t result;
49879
49880   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49881   {
49882     try {
49883       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);
49884     } catch (std::out_of_range& e) {
49885       {
49886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49887       };
49888     } catch (std::exception& e) {
49889       {
49890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49891       };
49892     } catch (...) {
49893       {
49894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49895       };
49896     }
49897   }
49898   jresult = (unsigned long)result;
49899   return jresult;
49900 }
49901
49902
49903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
49904   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49905   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
49906
49907   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49908   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
49909   {
49910     try {
49911       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49912     } catch (std::out_of_range& e) {
49913       {
49914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49915       };
49916     } catch (std::exception& e) {
49917       {
49918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49919       };
49920     } catch (...) {
49921       {
49922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49923       };
49924     }
49925   }
49926 }
49927
49928
49929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
49930   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49931   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
49932
49933   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49934   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
49935   {
49936     try {
49937       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49938     } catch (std::out_of_range& e) {
49939       {
49940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49941       };
49942     } catch (std::exception& e) {
49943       {
49944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49945       };
49946     } catch (...) {
49947       {
49948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49949       };
49950     }
49951   }
49952 }
49953
49954
49955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49956   unsigned int jresult ;
49957   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49958   Dali::Actor arg2 ;
49959   Dali::TouchData *arg3 = 0 ;
49960   Dali::Actor *argp2 ;
49961   bool result;
49962
49963   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49964   argp2 = (Dali::Actor *)jarg2;
49965   if (!argp2) {
49966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49967     return 0;
49968   }
49969   arg2 = *argp2;
49970   arg3 = (Dali::TouchData *)jarg3;
49971   if (!arg3) {
49972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
49973     return 0;
49974   }
49975   {
49976     try {
49977       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
49978     } catch (std::out_of_range& e) {
49979       {
49980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49981       };
49982     } catch (std::exception& e) {
49983       {
49984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49985       };
49986     } catch (...) {
49987       {
49988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49989       };
49990     }
49991   }
49992   jresult = result;
49993   return jresult;
49994 }
49995
49996
49997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
49998   void * jresult ;
49999   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50000
50001   {
50002     try {
50003       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50004     } catch (std::out_of_range& e) {
50005       {
50006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50007       };
50008     } catch (std::exception& e) {
50009       {
50010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50011       };
50012     } catch (...) {
50013       {
50014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50015       };
50016     }
50017   }
50018   jresult = (void *)result;
50019   return jresult;
50020 }
50021
50022
50023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50024   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50025
50026   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50027   {
50028     try {
50029       delete arg1;
50030     } catch (std::out_of_range& e) {
50031       {
50032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50033       };
50034     } catch (std::exception& e) {
50035       {
50036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50037       };
50038     } catch (...) {
50039       {
50040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50041       };
50042     }
50043   }
50044 }
50045
50046
50047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50048   unsigned int jresult ;
50049   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50050   bool result;
50051
50052   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50053   {
50054     try {
50055       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);
50056     } catch (std::out_of_range& e) {
50057       {
50058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50059       };
50060     } catch (std::exception& e) {
50061       {
50062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50063       };
50064     } catch (...) {
50065       {
50066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50067       };
50068     }
50069   }
50070   jresult = result;
50071   return jresult;
50072 }
50073
50074
50075 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50076   unsigned long jresult ;
50077   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50078   std::size_t result;
50079
50080   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50081   {
50082     try {
50083       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);
50084     } catch (std::out_of_range& e) {
50085       {
50086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50087       };
50088     } catch (std::exception& e) {
50089       {
50090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50091       };
50092     } catch (...) {
50093       {
50094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50095       };
50096     }
50097   }
50098   jresult = (unsigned long)result;
50099   return jresult;
50100 }
50101
50102
50103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50104   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50105   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50106
50107   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50108   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50109   {
50110     try {
50111       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50112     } catch (std::out_of_range& e) {
50113       {
50114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50115       };
50116     } catch (std::exception& e) {
50117       {
50118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50119       };
50120     } catch (...) {
50121       {
50122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50123       };
50124     }
50125   }
50126 }
50127
50128
50129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50130   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50131   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50132
50133   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50134   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50135   {
50136     try {
50137       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50138     } catch (std::out_of_range& e) {
50139       {
50140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50141       };
50142     } catch (std::exception& e) {
50143       {
50144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50145       };
50146     } catch (...) {
50147       {
50148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50149       };
50150     }
50151   }
50152 }
50153
50154
50155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50156   unsigned int jresult ;
50157   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50158   Dali::Actor arg2 ;
50159   Dali::HoverEvent *arg3 = 0 ;
50160   Dali::Actor *argp2 ;
50161   bool result;
50162
50163   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50164   argp2 = (Dali::Actor *)jarg2;
50165   if (!argp2) {
50166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50167     return 0;
50168   }
50169   arg2 = *argp2;
50170   arg3 = (Dali::HoverEvent *)jarg3;
50171   if (!arg3) {
50172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50173     return 0;
50174   }
50175   {
50176     try {
50177       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50178     } catch (std::out_of_range& e) {
50179       {
50180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50181       };
50182     } catch (std::exception& e) {
50183       {
50184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50185       };
50186     } catch (...) {
50187       {
50188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50189       };
50190     }
50191   }
50192   jresult = result;
50193   return jresult;
50194 }
50195
50196
50197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50198   void * jresult ;
50199   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50200
50201   {
50202     try {
50203       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50204     } catch (std::out_of_range& e) {
50205       {
50206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50207       };
50208     } catch (std::exception& e) {
50209       {
50210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50211       };
50212     } catch (...) {
50213       {
50214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50215       };
50216     }
50217   }
50218   jresult = (void *)result;
50219   return jresult;
50220 }
50221
50222
50223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50224   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50225
50226   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50227   {
50228     try {
50229       delete arg1;
50230     } catch (std::out_of_range& e) {
50231       {
50232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50233       };
50234     } catch (std::exception& e) {
50235       {
50236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50237       };
50238     } catch (...) {
50239       {
50240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50241       };
50242     }
50243   }
50244 }
50245
50246
50247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50248   unsigned int jresult ;
50249   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50250   bool result;
50251
50252   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50253   {
50254     try {
50255       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);
50256     } catch (std::out_of_range& e) {
50257       {
50258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50259       };
50260     } catch (std::exception& e) {
50261       {
50262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50263       };
50264     } catch (...) {
50265       {
50266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50267       };
50268     }
50269   }
50270   jresult = result;
50271   return jresult;
50272 }
50273
50274
50275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50276   unsigned long jresult ;
50277   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50278   std::size_t result;
50279
50280   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50281   {
50282     try {
50283       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);
50284     } catch (std::out_of_range& e) {
50285       {
50286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50287       };
50288     } catch (std::exception& e) {
50289       {
50290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50291       };
50292     } catch (...) {
50293       {
50294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50295       };
50296     }
50297   }
50298   jresult = (unsigned long)result;
50299   return jresult;
50300 }
50301
50302
50303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50304   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50305   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50306
50307   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50308   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50309   {
50310     try {
50311       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50312     } catch (std::out_of_range& e) {
50313       {
50314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50315       };
50316     } catch (std::exception& e) {
50317       {
50318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50319       };
50320     } catch (...) {
50321       {
50322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50323       };
50324     }
50325   }
50326 }
50327
50328
50329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50330   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50331   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50332
50333   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50334   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50335   {
50336     try {
50337       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50338     } catch (std::out_of_range& e) {
50339       {
50340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50341       };
50342     } catch (std::exception& e) {
50343       {
50344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50345       };
50346     } catch (...) {
50347       {
50348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50349       };
50350     }
50351   }
50352 }
50353
50354
50355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50356   unsigned int jresult ;
50357   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50358   Dali::Actor arg2 ;
50359   Dali::WheelEvent *arg3 = 0 ;
50360   Dali::Actor *argp2 ;
50361   bool result;
50362
50363   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50364   argp2 = (Dali::Actor *)jarg2;
50365   if (!argp2) {
50366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50367     return 0;
50368   }
50369   arg2 = *argp2;
50370   arg3 = (Dali::WheelEvent *)jarg3;
50371   if (!arg3) {
50372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50373     return 0;
50374   }
50375   {
50376     try {
50377       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50378     } catch (std::out_of_range& e) {
50379       {
50380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50381       };
50382     } catch (std::exception& e) {
50383       {
50384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50385       };
50386     } catch (...) {
50387       {
50388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50389       };
50390     }
50391   }
50392   jresult = result;
50393   return jresult;
50394 }
50395
50396
50397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50398   void * jresult ;
50399   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50400
50401   {
50402     try {
50403       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50404     } catch (std::out_of_range& e) {
50405       {
50406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50407       };
50408     } catch (std::exception& e) {
50409       {
50410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50411       };
50412     } catch (...) {
50413       {
50414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50415       };
50416     }
50417   }
50418   jresult = (void *)result;
50419   return jresult;
50420 }
50421
50422
50423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50424   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50425
50426   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50427   {
50428     try {
50429       delete arg1;
50430     } catch (std::out_of_range& e) {
50431       {
50432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50433       };
50434     } catch (std::exception& e) {
50435       {
50436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50437       };
50438     } catch (...) {
50439       {
50440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50441       };
50442     }
50443   }
50444 }
50445
50446
50447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50448   unsigned int jresult ;
50449   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50450   bool result;
50451
50452   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50453   {
50454     try {
50455       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50456     } catch (std::out_of_range& e) {
50457       {
50458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50459       };
50460     } catch (std::exception& e) {
50461       {
50462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50463       };
50464     } catch (...) {
50465       {
50466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50467       };
50468     }
50469   }
50470   jresult = result;
50471   return jresult;
50472 }
50473
50474
50475 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50476   unsigned long jresult ;
50477   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50478   std::size_t result;
50479
50480   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50481   {
50482     try {
50483       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50484     } catch (std::out_of_range& e) {
50485       {
50486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50487       };
50488     } catch (std::exception& e) {
50489       {
50490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50491       };
50492     } catch (...) {
50493       {
50494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50495       };
50496     }
50497   }
50498   jresult = (unsigned long)result;
50499   return jresult;
50500 }
50501
50502
50503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50504   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50505   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50506
50507   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50508   arg2 = (void (*)(Dali::Actor))jarg2;
50509   {
50510     try {
50511       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50512     } catch (std::out_of_range& e) {
50513       {
50514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50515       };
50516     } catch (std::exception& e) {
50517       {
50518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50519       };
50520     } catch (...) {
50521       {
50522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50523       };
50524     }
50525   }
50526 }
50527
50528
50529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50530   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50531   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50532
50533   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50534   arg2 = (void (*)(Dali::Actor))jarg2;
50535   {
50536     try {
50537       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50538     } catch (std::out_of_range& e) {
50539       {
50540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50541       };
50542     } catch (std::exception& e) {
50543       {
50544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50545       };
50546     } catch (...) {
50547       {
50548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50549       };
50550     }
50551   }
50552 }
50553
50554
50555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50556   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50557   Dali::Actor arg2 ;
50558   Dali::Actor *argp2 ;
50559
50560   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50561   argp2 = (Dali::Actor *)jarg2;
50562   if (!argp2) {
50563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50564     return ;
50565   }
50566   arg2 = *argp2;
50567   {
50568     try {
50569       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50570     } catch (std::out_of_range& e) {
50571       {
50572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50573       };
50574     } catch (std::exception& e) {
50575       {
50576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50577       };
50578     } catch (...) {
50579       {
50580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50581       };
50582     }
50583   }
50584 }
50585
50586
50587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50588   void * jresult ;
50589   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50590
50591   {
50592     try {
50593       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50594     } catch (std::out_of_range& e) {
50595       {
50596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50597       };
50598     } catch (std::exception& e) {
50599       {
50600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50601       };
50602     } catch (...) {
50603       {
50604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50605       };
50606     }
50607   }
50608   jresult = (void *)result;
50609   return jresult;
50610 }
50611
50612
50613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50614   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50615
50616   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50617   {
50618     try {
50619       delete arg1;
50620     } catch (std::out_of_range& e) {
50621       {
50622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50623       };
50624     } catch (std::exception& e) {
50625       {
50626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50627       };
50628     } catch (...) {
50629       {
50630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50631       };
50632     }
50633   }
50634 }
50635
50636
50637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50638   unsigned int jresult ;
50639   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50640   bool result;
50641
50642   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50643   {
50644     try {
50645       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50646     } catch (std::out_of_range& e) {
50647       {
50648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50649       };
50650     } catch (std::exception& e) {
50651       {
50652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50653       };
50654     } catch (...) {
50655       {
50656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50657       };
50658     }
50659   }
50660   jresult = result;
50661   return jresult;
50662 }
50663
50664
50665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50666   unsigned long jresult ;
50667   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50668   std::size_t result;
50669
50670   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50671   {
50672     try {
50673       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50674     } catch (std::out_of_range& e) {
50675       {
50676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50677       };
50678     } catch (std::exception& e) {
50679       {
50680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50681       };
50682     } catch (...) {
50683       {
50684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50685       };
50686     }
50687   }
50688   jresult = (unsigned long)result;
50689   return jresult;
50690 }
50691
50692
50693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50694   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50695   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50696
50697   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50698   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50699   {
50700     try {
50701       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50702     } catch (std::out_of_range& e) {
50703       {
50704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50705       };
50706     } catch (std::exception& e) {
50707       {
50708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50709       };
50710     } catch (...) {
50711       {
50712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50713       };
50714     }
50715   }
50716 }
50717
50718
50719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50720   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50721   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50722
50723   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50724   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50725   {
50726     try {
50727       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50728     } catch (std::out_of_range& e) {
50729       {
50730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50731       };
50732     } catch (std::exception& e) {
50733       {
50734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50735       };
50736     } catch (...) {
50737       {
50738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50739       };
50740     }
50741   }
50742 }
50743
50744
50745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
50746   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50747   Dali::KeyEvent *arg2 = 0 ;
50748
50749   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50750   arg2 = (Dali::KeyEvent *)jarg2;
50751   if (!arg2) {
50752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
50753     return ;
50754   }
50755   {
50756     try {
50757       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
50758     } catch (std::out_of_range& e) {
50759       {
50760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50761       };
50762     } catch (std::exception& e) {
50763       {
50764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50765       };
50766     } catch (...) {
50767       {
50768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50769       };
50770     }
50771   }
50772 }
50773
50774
50775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
50776   void * jresult ;
50777   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
50778
50779   {
50780     try {
50781       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
50782     } catch (std::out_of_range& e) {
50783       {
50784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50785       };
50786     } catch (std::exception& e) {
50787       {
50788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50789       };
50790     } catch (...) {
50791       {
50792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50793       };
50794     }
50795   }
50796   jresult = (void *)result;
50797   return jresult;
50798 }
50799
50800
50801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
50802   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50803
50804   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50805   {
50806     try {
50807       delete arg1;
50808     } catch (std::out_of_range& e) {
50809       {
50810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50811       };
50812     } catch (std::exception& e) {
50813       {
50814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50815       };
50816     } catch (...) {
50817       {
50818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50819       };
50820     }
50821   }
50822 }
50823
50824
50825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
50826   unsigned int jresult ;
50827   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50828   bool result;
50829
50830   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50831   {
50832     try {
50833       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50834     } catch (std::out_of_range& e) {
50835       {
50836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50837       };
50838     } catch (std::exception& e) {
50839       {
50840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50841       };
50842     } catch (...) {
50843       {
50844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50845       };
50846     }
50847   }
50848   jresult = result;
50849   return jresult;
50850 }
50851
50852
50853 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
50854   unsigned long jresult ;
50855   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50856   std::size_t result;
50857
50858   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50859   {
50860     try {
50861       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50862     } catch (std::out_of_range& e) {
50863       {
50864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50865       };
50866     } catch (std::exception& e) {
50867       {
50868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50869       };
50870     } catch (...) {
50871       {
50872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50873       };
50874     }
50875   }
50876   jresult = (unsigned long)result;
50877   return jresult;
50878 }
50879
50880
50881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
50882   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50883   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50884
50885   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50886   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50887   {
50888     try {
50889       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50890     } catch (std::out_of_range& e) {
50891       {
50892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50893       };
50894     } catch (std::exception& e) {
50895       {
50896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50897       };
50898     } catch (...) {
50899       {
50900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50901       };
50902     }
50903   }
50904 }
50905
50906
50907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
50908   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50909   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50910
50911   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50912   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50913   {
50914     try {
50915       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50916     } catch (std::out_of_range& e) {
50917       {
50918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50919       };
50920     } catch (std::exception& e) {
50921       {
50922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50923       };
50924     } catch (...) {
50925       {
50926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50927       };
50928     }
50929   }
50930 }
50931
50932
50933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
50934   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50935   Dali::TouchData *arg2 = 0 ;
50936
50937   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50938   arg2 = (Dali::TouchData *)jarg2;
50939   if (!arg2) {
50940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50941     return ;
50942   }
50943   {
50944     try {
50945       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
50946     } catch (std::out_of_range& e) {
50947       {
50948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50949       };
50950     } catch (std::exception& e) {
50951       {
50952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50953       };
50954     } catch (...) {
50955       {
50956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50957       };
50958     }
50959   }
50960 }
50961
50962
50963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
50964   void * jresult ;
50965   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
50966
50967   {
50968     try {
50969       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
50970     } catch (std::out_of_range& e) {
50971       {
50972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50973       };
50974     } catch (std::exception& e) {
50975       {
50976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50977       };
50978     } catch (...) {
50979       {
50980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50981       };
50982     }
50983   }
50984   jresult = (void *)result;
50985   return jresult;
50986 }
50987
50988
50989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
50990   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50991
50992   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50993   {
50994     try {
50995       delete arg1;
50996     } catch (std::out_of_range& e) {
50997       {
50998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (std::exception& e) {
51001       {
51002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51003       };
51004     } catch (...) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51007       };
51008     }
51009   }
51010 }
51011
51012
51013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51014   unsigned int jresult ;
51015   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51016   bool result;
51017
51018   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51019   {
51020     try {
51021       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51022     } catch (std::out_of_range& e) {
51023       {
51024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51025       };
51026     } catch (std::exception& e) {
51027       {
51028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51029       };
51030     } catch (...) {
51031       {
51032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51033       };
51034     }
51035   }
51036   jresult = result;
51037   return jresult;
51038 }
51039
51040
51041 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51042   unsigned long jresult ;
51043   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51044   std::size_t result;
51045
51046   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51047   {
51048     try {
51049       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51050     } catch (std::out_of_range& e) {
51051       {
51052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51053       };
51054     } catch (std::exception& e) {
51055       {
51056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51057       };
51058     } catch (...) {
51059       {
51060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51061       };
51062     }
51063   }
51064   jresult = (unsigned long)result;
51065   return jresult;
51066 }
51067
51068
51069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51070   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51071   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51072
51073   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51074   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51075   {
51076     try {
51077       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51078     } catch (std::out_of_range& e) {
51079       {
51080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51081       };
51082     } catch (std::exception& e) {
51083       {
51084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51085       };
51086     } catch (...) {
51087       {
51088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51089       };
51090     }
51091   }
51092 }
51093
51094
51095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51096   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51097   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51098
51099   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51100   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51101   {
51102     try {
51103       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51104     } catch (std::out_of_range& e) {
51105       {
51106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51107       };
51108     } catch (std::exception& e) {
51109       {
51110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51111       };
51112     } catch (...) {
51113       {
51114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51115       };
51116     }
51117   }
51118 }
51119
51120
51121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51122   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51123   Dali::WheelEvent *arg2 = 0 ;
51124
51125   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51126   arg2 = (Dali::WheelEvent *)jarg2;
51127   if (!arg2) {
51128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51129     return ;
51130   }
51131   {
51132     try {
51133       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51134     } catch (std::out_of_range& e) {
51135       {
51136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51137       };
51138     } catch (std::exception& e) {
51139       {
51140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51141       };
51142     } catch (...) {
51143       {
51144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51145       };
51146     }
51147   }
51148 }
51149
51150
51151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51152   void * jresult ;
51153   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51154
51155   {
51156     try {
51157       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51158     } catch (std::out_of_range& e) {
51159       {
51160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51161       };
51162     } catch (std::exception& e) {
51163       {
51164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51165       };
51166     } catch (...) {
51167       {
51168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51169       };
51170     }
51171   }
51172   jresult = (void *)result;
51173   return jresult;
51174 }
51175
51176
51177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51178   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51179
51180   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51181   {
51182     try {
51183       delete arg1;
51184     } catch (std::out_of_range& e) {
51185       {
51186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51187       };
51188     } catch (std::exception& e) {
51189       {
51190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51191       };
51192     } catch (...) {
51193       {
51194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51195       };
51196     }
51197   }
51198 }
51199
51200
51201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51202   void * jresult ;
51203   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51204
51205   {
51206     try {
51207       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51208     } catch (std::out_of_range& e) {
51209       {
51210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51211       };
51212     } catch (std::exception& e) {
51213       {
51214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51215       };
51216     } catch (...) {
51217       {
51218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51219       };
51220     }
51221   }
51222   jresult = (void *)result;
51223   return jresult;
51224 }
51225
51226
51227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51228   void * jresult ;
51229   Dali::Radian arg1 ;
51230   Dali::Radian arg2 ;
51231   Dali::Radian *argp1 ;
51232   Dali::Radian *argp2 ;
51233   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51234
51235   argp1 = (Dali::Radian *)jarg1;
51236   if (!argp1) {
51237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51238     return 0;
51239   }
51240   arg1 = *argp1;
51241   argp2 = (Dali::Radian *)jarg2;
51242   if (!argp2) {
51243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51244     return 0;
51245   }
51246   arg2 = *argp2;
51247   {
51248     try {
51249       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51250     } catch (std::out_of_range& e) {
51251       {
51252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51253       };
51254     } catch (std::exception& e) {
51255       {
51256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51257       };
51258     } catch (...) {
51259       {
51260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51261       };
51262     }
51263   }
51264   jresult = (void *)result;
51265   return jresult;
51266 }
51267
51268
51269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51270   void * jresult ;
51271   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51272   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51273
51274   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51275   if (!arg1) {
51276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51277     return 0;
51278   }
51279   {
51280     try {
51281       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51282     } catch (std::out_of_range& e) {
51283       {
51284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51285       };
51286     } catch (std::exception& e) {
51287       {
51288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51289       };
51290     } catch (...) {
51291       {
51292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51293       };
51294     }
51295   }
51296   jresult = (void *)result;
51297   return jresult;
51298 }
51299
51300
51301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51302   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51303   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51304
51305   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51306   arg2 = (Dali::Radian *)jarg2;
51307   if (arg1) (arg1)->first = *arg2;
51308 }
51309
51310
51311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51312   void * jresult ;
51313   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51314   Dali::Radian *result = 0 ;
51315
51316   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51317   result = (Dali::Radian *)& ((arg1)->first);
51318   jresult = (void *)result;
51319   return jresult;
51320 }
51321
51322
51323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51324   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51325   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51326
51327   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51328   arg2 = (Dali::Radian *)jarg2;
51329   if (arg1) (arg1)->second = *arg2;
51330 }
51331
51332
51333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51334   void * jresult ;
51335   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51336   Dali::Radian *result = 0 ;
51337
51338   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51339   result = (Dali::Radian *)& ((arg1)->second);
51340   jresult = (void *)result;
51341   return jresult;
51342 }
51343
51344
51345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51346   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51347
51348   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51349   {
51350     try {
51351       delete arg1;
51352     } catch (std::out_of_range& e) {
51353       {
51354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51355       };
51356     } catch (std::exception& e) {
51357       {
51358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51359       };
51360     } catch (...) {
51361       {
51362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51363       };
51364     }
51365   }
51366 }
51367
51368
51369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51370   unsigned int jresult ;
51371   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51372   bool result;
51373
51374   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51375   {
51376     try {
51377       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);
51378     } catch (std::out_of_range& e) {
51379       {
51380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51381       };
51382     } catch (std::exception& e) {
51383       {
51384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51385       };
51386     } catch (...) {
51387       {
51388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51389       };
51390     }
51391   }
51392   jresult = result;
51393   return jresult;
51394 }
51395
51396
51397 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51398   unsigned long jresult ;
51399   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51400   std::size_t result;
51401
51402   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51403   {
51404     try {
51405       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);
51406     } catch (std::out_of_range& e) {
51407       {
51408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51409       };
51410     } catch (std::exception& e) {
51411       {
51412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51413       };
51414     } catch (...) {
51415       {
51416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51417       };
51418     }
51419   }
51420   jresult = (unsigned long)result;
51421   return jresult;
51422 }
51423
51424
51425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51426   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51427   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51428
51429   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51430   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51431   {
51432     try {
51433       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51434     } catch (std::out_of_range& e) {
51435       {
51436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51437       };
51438     } catch (std::exception& e) {
51439       {
51440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51441       };
51442     } catch (...) {
51443       {
51444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51445       };
51446     }
51447   }
51448 }
51449
51450
51451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51452   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51453   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51454
51455   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51456   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51457   {
51458     try {
51459       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51460     } catch (std::out_of_range& e) {
51461       {
51462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51463       };
51464     } catch (std::exception& e) {
51465       {
51466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51467       };
51468     } catch (...) {
51469       {
51470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51471       };
51472     }
51473   }
51474 }
51475
51476
51477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51478   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51479   Dali::Actor arg2 ;
51480   Dali::PanGesture *arg3 = 0 ;
51481   Dali::Actor *argp2 ;
51482
51483   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51484   argp2 = (Dali::Actor *)jarg2;
51485   if (!argp2) {
51486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51487     return ;
51488   }
51489   arg2 = *argp2;
51490   arg3 = (Dali::PanGesture *)jarg3;
51491   if (!arg3) {
51492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51493     return ;
51494   }
51495   {
51496     try {
51497       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51498     } catch (std::out_of_range& e) {
51499       {
51500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51501       };
51502     } catch (std::exception& e) {
51503       {
51504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51505       };
51506     } catch (...) {
51507       {
51508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51509       };
51510     }
51511   }
51512 }
51513
51514
51515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51516   void * jresult ;
51517   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51518
51519   {
51520     try {
51521       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51522     } catch (std::out_of_range& e) {
51523       {
51524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51525       };
51526     } catch (std::exception& e) {
51527       {
51528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51529       };
51530     } catch (...) {
51531       {
51532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51533       };
51534     }
51535   }
51536   jresult = (void *)result;
51537   return jresult;
51538 }
51539
51540
51541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51542   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51543
51544   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51545   {
51546     try {
51547       delete arg1;
51548     } catch (std::out_of_range& e) {
51549       {
51550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51551       };
51552     } catch (std::exception& e) {
51553       {
51554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51555       };
51556     } catch (...) {
51557       {
51558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51559       };
51560     }
51561   }
51562 }
51563
51564
51565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51566   unsigned int jresult ;
51567   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51568   bool result;
51569
51570   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51571   {
51572     try {
51573       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);
51574     } catch (std::out_of_range& e) {
51575       {
51576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51577       };
51578     } catch (std::exception& e) {
51579       {
51580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51581       };
51582     } catch (...) {
51583       {
51584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51585       };
51586     }
51587   }
51588   jresult = result;
51589   return jresult;
51590 }
51591
51592
51593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51594   unsigned long jresult ;
51595   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51596   std::size_t result;
51597
51598   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51599   {
51600     try {
51601       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);
51602     } catch (std::out_of_range& e) {
51603       {
51604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51605       };
51606     } catch (std::exception& e) {
51607       {
51608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51609       };
51610     } catch (...) {
51611       {
51612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51613       };
51614     }
51615   }
51616   jresult = (unsigned long)result;
51617   return jresult;
51618 }
51619
51620
51621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51622   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51623   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51624
51625   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51626   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51627   {
51628     try {
51629       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51630     } catch (std::out_of_range& e) {
51631       {
51632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51633       };
51634     } catch (std::exception& e) {
51635       {
51636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51637       };
51638     } catch (...) {
51639       {
51640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51641       };
51642     }
51643   }
51644 }
51645
51646
51647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51648   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51649   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51650
51651   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51652   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51653   {
51654     try {
51655       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51656     } catch (std::out_of_range& e) {
51657       {
51658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51659       };
51660     } catch (std::exception& e) {
51661       {
51662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51663       };
51664     } catch (...) {
51665       {
51666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51667       };
51668     }
51669   }
51670 }
51671
51672
51673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51674   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51675   Dali::Actor arg2 ;
51676   Dali::PinchGesture *arg3 = 0 ;
51677   Dali::Actor *argp2 ;
51678
51679   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51680   argp2 = (Dali::Actor *)jarg2;
51681   if (!argp2) {
51682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51683     return ;
51684   }
51685   arg2 = *argp2;
51686   arg3 = (Dali::PinchGesture *)jarg3;
51687   if (!arg3) {
51688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51689     return ;
51690   }
51691   {
51692     try {
51693       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51694     } catch (std::out_of_range& e) {
51695       {
51696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51697       };
51698     } catch (std::exception& e) {
51699       {
51700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51701       };
51702     } catch (...) {
51703       {
51704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51705       };
51706     }
51707   }
51708 }
51709
51710
51711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51712   void * jresult ;
51713   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51714
51715   {
51716     try {
51717       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51718     } catch (std::out_of_range& e) {
51719       {
51720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51721       };
51722     } catch (std::exception& e) {
51723       {
51724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51725       };
51726     } catch (...) {
51727       {
51728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51729       };
51730     }
51731   }
51732   jresult = (void *)result;
51733   return jresult;
51734 }
51735
51736
51737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
51738   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51739
51740   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51741   {
51742     try {
51743       delete arg1;
51744     } catch (std::out_of_range& e) {
51745       {
51746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51747       };
51748     } catch (std::exception& e) {
51749       {
51750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51751       };
51752     } catch (...) {
51753       {
51754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51755       };
51756     }
51757   }
51758 }
51759
51760
51761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
51762   unsigned int jresult ;
51763   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51764   bool result;
51765
51766   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51767   {
51768     try {
51769       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);
51770     } catch (std::out_of_range& e) {
51771       {
51772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51773       };
51774     } catch (std::exception& e) {
51775       {
51776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51777       };
51778     } catch (...) {
51779       {
51780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51781       };
51782     }
51783   }
51784   jresult = result;
51785   return jresult;
51786 }
51787
51788
51789 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51790   unsigned long jresult ;
51791   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51792   std::size_t result;
51793
51794   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51795   {
51796     try {
51797       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);
51798     } catch (std::out_of_range& e) {
51799       {
51800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51801       };
51802     } catch (std::exception& e) {
51803       {
51804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51805       };
51806     } catch (...) {
51807       {
51808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51809       };
51810     }
51811   }
51812   jresult = (unsigned long)result;
51813   return jresult;
51814 }
51815
51816
51817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51818   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51819   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51820
51821   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51822   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51823   {
51824     try {
51825       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51826     } catch (std::out_of_range& e) {
51827       {
51828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51829       };
51830     } catch (std::exception& e) {
51831       {
51832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51833       };
51834     } catch (...) {
51835       {
51836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51837       };
51838     }
51839   }
51840 }
51841
51842
51843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51844   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51845   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51846
51847   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51848   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51849   {
51850     try {
51851       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51852     } catch (std::out_of_range& e) {
51853       {
51854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51855       };
51856     } catch (std::exception& e) {
51857       {
51858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51859       };
51860     } catch (...) {
51861       {
51862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51863       };
51864     }
51865   }
51866 }
51867
51868
51869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51870   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51871   Dali::Actor arg2 ;
51872   Dali::TapGesture *arg3 = 0 ;
51873   Dali::Actor *argp2 ;
51874
51875   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51876   argp2 = (Dali::Actor *)jarg2;
51877   if (!argp2) {
51878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51879     return ;
51880   }
51881   arg2 = *argp2;
51882   arg3 = (Dali::TapGesture *)jarg3;
51883   if (!arg3) {
51884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
51885     return ;
51886   }
51887   {
51888     try {
51889       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
51890     } catch (std::out_of_range& e) {
51891       {
51892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51893       };
51894     } catch (std::exception& e) {
51895       {
51896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51897       };
51898     } catch (...) {
51899       {
51900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51901       };
51902     }
51903   }
51904 }
51905
51906
51907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
51908   void * jresult ;
51909   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
51910
51911   {
51912     try {
51913       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
51914     } catch (std::out_of_range& e) {
51915       {
51916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51917       };
51918     } catch (std::exception& e) {
51919       {
51920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51921       };
51922     } catch (...) {
51923       {
51924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51925       };
51926     }
51927   }
51928   jresult = (void *)result;
51929   return jresult;
51930 }
51931
51932
51933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
51934   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51935
51936   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51937   {
51938     try {
51939       delete arg1;
51940     } catch (std::out_of_range& e) {
51941       {
51942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51943       };
51944     } catch (std::exception& e) {
51945       {
51946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51947       };
51948     } catch (...) {
51949       {
51950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51951       };
51952     }
51953   }
51954 }
51955
51956
51957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
51958   unsigned int jresult ;
51959   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
51960   bool result;
51961
51962   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
51963   {
51964     try {
51965       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
51966     } catch (std::out_of_range& e) {
51967       {
51968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51969       };
51970     } catch (std::exception& e) {
51971       {
51972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51973       };
51974     } catch (...) {
51975       {
51976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51977       };
51978     }
51979   }
51980   jresult = result;
51981   return jresult;
51982 }
51983
51984
51985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
51986   unsigned long jresult ;
51987   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
51988   std::size_t result;
51989
51990   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
51991   {
51992     try {
51993       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
51994     } catch (std::out_of_range& e) {
51995       {
51996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51997       };
51998     } catch (std::exception& e) {
51999       {
52000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52001       };
52002     } catch (...) {
52003       {
52004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52005       };
52006     }
52007   }
52008   jresult = (unsigned long)result;
52009   return jresult;
52010 }
52011
52012
52013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52014   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52015   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52016
52017   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52018   arg2 = (void (*)(Dali::Animation &))jarg2;
52019   {
52020     try {
52021       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52022     } catch (std::out_of_range& e) {
52023       {
52024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52025       };
52026     } catch (std::exception& e) {
52027       {
52028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52029       };
52030     } catch (...) {
52031       {
52032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52033       };
52034     }
52035   }
52036 }
52037
52038
52039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52040   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52041   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52042
52043   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52044   arg2 = (void (*)(Dali::Animation &))jarg2;
52045   {
52046     try {
52047       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52048     } catch (std::out_of_range& e) {
52049       {
52050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52051       };
52052     } catch (std::exception& e) {
52053       {
52054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52055       };
52056     } catch (...) {
52057       {
52058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52059       };
52060     }
52061   }
52062 }
52063
52064
52065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52066   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52067   Dali::Animation *arg2 = 0 ;
52068
52069   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52070   arg2 = (Dali::Animation *)jarg2;
52071   if (!arg2) {
52072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52073     return ;
52074   }
52075   {
52076     try {
52077       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52078     } catch (std::out_of_range& e) {
52079       {
52080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52081       };
52082     } catch (std::exception& e) {
52083       {
52084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52085       };
52086     } catch (...) {
52087       {
52088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52089       };
52090     }
52091   }
52092 }
52093
52094
52095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52096   void * jresult ;
52097   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52098
52099   {
52100     try {
52101       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52102     } catch (std::out_of_range& e) {
52103       {
52104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52105       };
52106     } catch (std::exception& e) {
52107       {
52108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52109       };
52110     } catch (...) {
52111       {
52112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52113       };
52114     }
52115   }
52116   jresult = (void *)result;
52117   return jresult;
52118 }
52119
52120
52121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52122   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52123
52124   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52125   {
52126     try {
52127       delete arg1;
52128     } catch (std::out_of_range& e) {
52129       {
52130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52131       };
52132     } catch (std::exception& e) {
52133       {
52134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52135       };
52136     } catch (...) {
52137       {
52138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52139       };
52140     }
52141   }
52142 }
52143
52144
52145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52146   unsigned int jresult ;
52147   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52148   bool result;
52149
52150   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52151   {
52152     try {
52153       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52154     } catch (std::out_of_range& e) {
52155       {
52156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52157       };
52158     } catch (std::exception& e) {
52159       {
52160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52161       };
52162     } catch (...) {
52163       {
52164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52165       };
52166     }
52167   }
52168   jresult = result;
52169   return jresult;
52170 }
52171
52172
52173 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52174   unsigned long jresult ;
52175   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52176   std::size_t result;
52177
52178   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52179   {
52180     try {
52181       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52182     } catch (std::out_of_range& e) {
52183       {
52184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52185       };
52186     } catch (std::exception& e) {
52187       {
52188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52189       };
52190     } catch (...) {
52191       {
52192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52193       };
52194     }
52195   }
52196   jresult = (unsigned long)result;
52197   return jresult;
52198 }
52199
52200
52201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52202   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52203   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52204
52205   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52206   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52207   {
52208     try {
52209       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52210     } catch (std::out_of_range& e) {
52211       {
52212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52213       };
52214     } catch (std::exception& e) {
52215       {
52216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52217       };
52218     } catch (...) {
52219       {
52220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52221       };
52222     }
52223   }
52224 }
52225
52226
52227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52228   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52229   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52230
52231   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52232   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52233   {
52234     try {
52235       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52236     } catch (std::out_of_range& e) {
52237       {
52238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52239       };
52240     } catch (std::exception& e) {
52241       {
52242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52243       };
52244     } catch (...) {
52245       {
52246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52247       };
52248     }
52249   }
52250 }
52251
52252
52253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52254   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52255   Dali::ResourceImage arg2 ;
52256   Dali::ResourceImage *argp2 ;
52257
52258   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52259   argp2 = (Dali::ResourceImage *)jarg2;
52260   if (!argp2) {
52261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52262     return ;
52263   }
52264   arg2 = *argp2;
52265   {
52266     try {
52267       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52268     } catch (std::out_of_range& e) {
52269       {
52270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52271       };
52272     } catch (std::exception& e) {
52273       {
52274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52275       };
52276     } catch (...) {
52277       {
52278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52279       };
52280     }
52281   }
52282 }
52283
52284
52285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52286   void * jresult ;
52287   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52288
52289   {
52290     try {
52291       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52292     } catch (std::out_of_range& e) {
52293       {
52294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52295       };
52296     } catch (std::exception& e) {
52297       {
52298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52299       };
52300     } catch (...) {
52301       {
52302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52303       };
52304     }
52305   }
52306   jresult = (void *)result;
52307   return jresult;
52308 }
52309
52310
52311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52312   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52313
52314   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52315   {
52316     try {
52317       delete arg1;
52318     } catch (std::out_of_range& e) {
52319       {
52320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52321       };
52322     } catch (std::exception& e) {
52323       {
52324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52325       };
52326     } catch (...) {
52327       {
52328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52329       };
52330     }
52331   }
52332 }
52333
52334
52335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52336   void * jresult ;
52337   Dali::Timer *result = 0 ;
52338
52339   {
52340     try {
52341       result = (Dali::Timer *)new Dali::Timer();
52342     } catch (std::out_of_range& e) {
52343       {
52344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52345       };
52346     } catch (std::exception& e) {
52347       {
52348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52349       };
52350     } catch (...) {
52351       {
52352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52353       };
52354     }
52355   }
52356   jresult = (void *)result;
52357   return jresult;
52358 }
52359
52360
52361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52362   void * jresult ;
52363   unsigned int arg1 ;
52364   Dali::Timer result;
52365
52366   arg1 = (unsigned int)jarg1;
52367   {
52368     try {
52369       result = Dali::Timer::New(arg1);
52370     } catch (std::out_of_range& e) {
52371       {
52372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52373       };
52374     } catch (std::exception& e) {
52375       {
52376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52377       };
52378     } catch (...) {
52379       {
52380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52381       };
52382     }
52383   }
52384   jresult = new Dali::Timer((const Dali::Timer &)result);
52385   return jresult;
52386 }
52387
52388
52389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52390   void * jresult ;
52391   Dali::Timer *arg1 = 0 ;
52392   Dali::Timer *result = 0 ;
52393
52394   arg1 = (Dali::Timer *)jarg1;
52395   if (!arg1) {
52396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52397     return 0;
52398   }
52399   {
52400     try {
52401       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52402     } catch (std::out_of_range& e) {
52403       {
52404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52405       };
52406     } catch (std::exception& e) {
52407       {
52408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52409       };
52410     } catch (...) {
52411       {
52412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52413       };
52414     }
52415   }
52416   jresult = (void *)result;
52417   return jresult;
52418 }
52419
52420
52421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52422   void * jresult ;
52423   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52424   Dali::Timer *arg2 = 0 ;
52425   Dali::Timer *result = 0 ;
52426
52427   arg1 = (Dali::Timer *)jarg1;
52428   arg2 = (Dali::Timer *)jarg2;
52429   if (!arg2) {
52430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52431     return 0;
52432   }
52433   {
52434     try {
52435       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52436     } catch (std::out_of_range& e) {
52437       {
52438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52439       };
52440     } catch (std::exception& e) {
52441       {
52442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52443       };
52444     } catch (...) {
52445       {
52446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52447       };
52448     }
52449   }
52450   jresult = (void *)result;
52451   return jresult;
52452 }
52453
52454
52455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52456   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52457
52458   arg1 = (Dali::Timer *)jarg1;
52459   {
52460     try {
52461       delete arg1;
52462     } catch (std::out_of_range& e) {
52463       {
52464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52465       };
52466     } catch (std::exception& e) {
52467       {
52468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52469       };
52470     } catch (...) {
52471       {
52472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52473       };
52474     }
52475   }
52476 }
52477
52478
52479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52480   void * jresult ;
52481   Dali::BaseHandle arg1 ;
52482   Dali::BaseHandle *argp1 ;
52483   Dali::Timer result;
52484
52485   argp1 = (Dali::BaseHandle *)jarg1;
52486   if (!argp1) {
52487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52488     return 0;
52489   }
52490   arg1 = *argp1;
52491   {
52492     try {
52493       result = Dali::Timer::DownCast(arg1);
52494     } catch (std::out_of_range& e) {
52495       {
52496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52497       };
52498     } catch (std::exception& e) {
52499       {
52500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52501       };
52502     } catch (...) {
52503       {
52504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52505       };
52506     }
52507   }
52508   jresult = new Dali::Timer((const Dali::Timer &)result);
52509   return jresult;
52510 }
52511
52512
52513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52514   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52515
52516   arg1 = (Dali::Timer *)jarg1;
52517   {
52518     try {
52519       (arg1)->Start();
52520     } catch (std::out_of_range& e) {
52521       {
52522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52523       };
52524     } catch (std::exception& e) {
52525       {
52526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52527       };
52528     } catch (...) {
52529       {
52530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52531       };
52532     }
52533   }
52534 }
52535
52536
52537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52538   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52539
52540   arg1 = (Dali::Timer *)jarg1;
52541   {
52542     try {
52543       (arg1)->Stop();
52544     } catch (std::out_of_range& e) {
52545       {
52546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52547       };
52548     } catch (std::exception& e) {
52549       {
52550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52551       };
52552     } catch (...) {
52553       {
52554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52555       };
52556     }
52557   }
52558 }
52559
52560
52561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52562   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52563   unsigned int arg2 ;
52564
52565   arg1 = (Dali::Timer *)jarg1;
52566   arg2 = (unsigned int)jarg2;
52567   {
52568     try {
52569       (arg1)->SetInterval(arg2);
52570     } catch (std::out_of_range& e) {
52571       {
52572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52573       };
52574     } catch (std::exception& e) {
52575       {
52576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52577       };
52578     } catch (...) {
52579       {
52580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52581       };
52582     }
52583   }
52584 }
52585
52586
52587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52588   unsigned int jresult ;
52589   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52590   unsigned int result;
52591
52592   arg1 = (Dali::Timer *)jarg1;
52593   {
52594     try {
52595       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52596     } catch (std::out_of_range& e) {
52597       {
52598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52599       };
52600     } catch (std::exception& e) {
52601       {
52602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52603       };
52604     } catch (...) {
52605       {
52606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52607       };
52608     }
52609   }
52610   jresult = result;
52611   return jresult;
52612 }
52613
52614
52615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52616   unsigned int jresult ;
52617   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52618   bool result;
52619
52620   arg1 = (Dali::Timer *)jarg1;
52621   {
52622     try {
52623       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52624     } catch (std::out_of_range& e) {
52625       {
52626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52627       };
52628     } catch (std::exception& e) {
52629       {
52630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52631       };
52632     } catch (...) {
52633       {
52634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52635       };
52636     }
52637   }
52638   jresult = result;
52639   return jresult;
52640 }
52641
52642
52643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52644   void * jresult ;
52645   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52646   Dali::Timer::TimerSignalType *result = 0 ;
52647
52648   arg1 = (Dali::Timer *)jarg1;
52649   {
52650     try {
52651       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52652     } catch (std::out_of_range& e) {
52653       {
52654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52655       };
52656     } catch (std::exception& e) {
52657       {
52658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52659       };
52660     } catch (...) {
52661       {
52662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52663       };
52664     }
52665   }
52666   jresult = (void *)result;
52667   return jresult;
52668 }
52669
52670
52671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
52672   void * jresult ;
52673   Dali::DragAndDropDetector *result = 0 ;
52674
52675   {
52676     try {
52677       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
52678     } catch (std::out_of_range& e) {
52679       {
52680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52681       };
52682     } catch (std::exception& e) {
52683       {
52684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52685       };
52686     } catch (...) {
52687       {
52688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52689       };
52690     }
52691   }
52692   jresult = (void *)result;
52693   return jresult;
52694 }
52695
52696
52697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
52698   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52699
52700   arg1 = (Dali::DragAndDropDetector *)jarg1;
52701   {
52702     try {
52703       delete arg1;
52704     } catch (std::out_of_range& e) {
52705       {
52706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52707       };
52708     } catch (std::exception& e) {
52709       {
52710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52711       };
52712     } catch (...) {
52713       {
52714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52715       };
52716     }
52717   }
52718 }
52719
52720
52721 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
52722   char * jresult ;
52723   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52724   std::string *result = 0 ;
52725
52726   arg1 = (Dali::DragAndDropDetector *)jarg1;
52727   {
52728     try {
52729       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
52730     } catch (std::out_of_range& e) {
52731       {
52732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52733       };
52734     } catch (std::exception& e) {
52735       {
52736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52737       };
52738     } catch (...) {
52739       {
52740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52741       };
52742     }
52743   }
52744   jresult = SWIG_csharp_string_callback(result->c_str());
52745   return jresult;
52746 }
52747
52748
52749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
52750   void * jresult ;
52751   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52752   Dali::Vector2 result;
52753
52754   arg1 = (Dali::DragAndDropDetector *)jarg1;
52755   {
52756     try {
52757       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
52758     } catch (std::out_of_range& e) {
52759       {
52760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52761       };
52762     } catch (std::exception& e) {
52763       {
52764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52765       };
52766     } catch (...) {
52767       {
52768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52769       };
52770     }
52771   }
52772   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
52773   return jresult;
52774 }
52775
52776
52777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
52778   void * jresult ;
52779   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52780   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52781
52782   arg1 = (Dali::DragAndDropDetector *)jarg1;
52783   {
52784     try {
52785       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
52786     } catch (std::out_of_range& e) {
52787       {
52788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52789       };
52790     } catch (std::exception& e) {
52791       {
52792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52793       };
52794     } catch (...) {
52795       {
52796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52797       };
52798     }
52799   }
52800   jresult = (void *)result;
52801   return jresult;
52802 }
52803
52804
52805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
52806   void * jresult ;
52807   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52808   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52809
52810   arg1 = (Dali::DragAndDropDetector *)jarg1;
52811   {
52812     try {
52813       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
52814     } catch (std::out_of_range& e) {
52815       {
52816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52817       };
52818     } catch (std::exception& e) {
52819       {
52820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52821       };
52822     } catch (...) {
52823       {
52824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52825       };
52826     }
52827   }
52828   jresult = (void *)result;
52829   return jresult;
52830 }
52831
52832
52833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
52834   void * jresult ;
52835   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52836   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52837
52838   arg1 = (Dali::DragAndDropDetector *)jarg1;
52839   {
52840     try {
52841       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
52842     } catch (std::out_of_range& e) {
52843       {
52844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52845       };
52846     } catch (std::exception& e) {
52847       {
52848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52849       };
52850     } catch (...) {
52851       {
52852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52853       };
52854     }
52855   }
52856   jresult = (void *)result;
52857   return jresult;
52858 }
52859
52860
52861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
52862   void * jresult ;
52863   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52864   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52865
52866   arg1 = (Dali::DragAndDropDetector *)jarg1;
52867   {
52868     try {
52869       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
52870     } catch (std::out_of_range& e) {
52871       {
52872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52873       };
52874     } catch (std::exception& e) {
52875       {
52876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52877       };
52878     } catch (...) {
52879       {
52880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52881       };
52882     }
52883   }
52884   jresult = (void *)result;
52885   return jresult;
52886 }
52887
52888
52889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
52890   void * jresult ;
52891   Dali::ApplicationExtensions *result = 0 ;
52892
52893   {
52894     try {
52895       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
52896     } catch (std::out_of_range& e) {
52897       {
52898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52899       };
52900     } catch (std::exception& e) {
52901       {
52902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52903       };
52904     } catch (...) {
52905       {
52906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52907       };
52908     }
52909   }
52910   jresult = (void *)result;
52911   return jresult;
52912 }
52913
52914
52915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
52916   void * jresult ;
52917   Dali::Application *arg1 = (Dali::Application *) 0 ;
52918   Dali::ApplicationExtensions *result = 0 ;
52919
52920   arg1 = (Dali::Application *)jarg1;
52921   {
52922     try {
52923       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
52924     } catch (std::out_of_range& e) {
52925       {
52926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52927       };
52928     } catch (std::exception& e) {
52929       {
52930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52931       };
52932     } catch (...) {
52933       {
52934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52935       };
52936     }
52937   }
52938   jresult = (void *)result;
52939   return jresult;
52940 }
52941
52942
52943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
52944   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
52945
52946   arg1 = (Dali::ApplicationExtensions *)jarg1;
52947   {
52948     try {
52949       delete arg1;
52950     } catch (std::out_of_range& e) {
52951       {
52952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52953       };
52954     } catch (std::exception& e) {
52955       {
52956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52957       };
52958     } catch (...) {
52959       {
52960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52961       };
52962     }
52963   }
52964 }
52965
52966
52967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
52968   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
52969
52970   arg1 = (Dali::ApplicationExtensions *)jarg1;
52971   {
52972     try {
52973       (arg1)->Init();
52974     } catch (std::out_of_range& e) {
52975       {
52976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52977       };
52978     } catch (std::exception& e) {
52979       {
52980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52981       };
52982     } catch (...) {
52983       {
52984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52985       };
52986     }
52987   }
52988 }
52989
52990
52991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
52992   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
52993
52994   arg1 = (Dali::ApplicationExtensions *)jarg1;
52995   {
52996     try {
52997       (arg1)->Terminate();
52998     } catch (std::out_of_range& e) {
52999       {
53000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53001       };
53002     } catch (std::exception& e) {
53003       {
53004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53005       };
53006     } catch (...) {
53007       {
53008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53009       };
53010     }
53011   }
53012 }
53013
53014
53015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53016   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53017
53018   arg1 = (Dali::ApplicationExtensions *)jarg1;
53019   {
53020     try {
53021       (arg1)->Pause();
53022     } catch (std::out_of_range& e) {
53023       {
53024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53025       };
53026     } catch (std::exception& e) {
53027       {
53028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53029       };
53030     } catch (...) {
53031       {
53032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53033       };
53034     }
53035   }
53036 }
53037
53038
53039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53040   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53041
53042   arg1 = (Dali::ApplicationExtensions *)jarg1;
53043   {
53044     try {
53045       (arg1)->Resume();
53046     } catch (std::out_of_range& e) {
53047       {
53048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53049       };
53050     } catch (std::exception& e) {
53051       {
53052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53053       };
53054     } catch (...) {
53055       {
53056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53057       };
53058     }
53059   }
53060 }
53061
53062
53063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53064   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53065
53066   arg1 = (Dali::ApplicationExtensions *)jarg1;
53067   {
53068     try {
53069       (arg1)->LanguageChange();
53070     } catch (std::out_of_range& e) {
53071       {
53072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53073       };
53074     } catch (std::exception& e) {
53075       {
53076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53077       };
53078     } catch (...) {
53079       {
53080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53081       };
53082     }
53083   }
53084 }
53085
53086
53087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53088   void * jresult ;
53089   Dali::PositionSize arg1 ;
53090   std::string *arg2 = 0 ;
53091   bool arg3 ;
53092   Dali::PositionSize *argp1 ;
53093   Dali::Window result;
53094
53095   argp1 = (Dali::PositionSize *)jarg1;
53096   if (!argp1) {
53097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53098     return 0;
53099   }
53100   arg1 = *argp1;
53101   if (!jarg2) {
53102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53103     return 0;
53104   }
53105   std::string arg2_str(jarg2);
53106   arg2 = &arg2_str;
53107   arg3 = jarg3 ? true : false;
53108   {
53109     try {
53110       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53111     } catch (std::out_of_range& e) {
53112       {
53113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53114       };
53115     } catch (std::exception& e) {
53116       {
53117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53118       };
53119     } catch (...) {
53120       {
53121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53122       };
53123     }
53124   }
53125   jresult = new Dali::Window((const Dali::Window &)result);
53126
53127   //argout typemap for const std::string&
53128
53129   return jresult;
53130 }
53131
53132
53133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53134   void * jresult ;
53135   Dali::PositionSize arg1 ;
53136   std::string *arg2 = 0 ;
53137   Dali::PositionSize *argp1 ;
53138   Dali::Window result;
53139
53140   argp1 = (Dali::PositionSize *)jarg1;
53141   if (!argp1) {
53142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53143     return 0;
53144   }
53145   arg1 = *argp1;
53146   if (!jarg2) {
53147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53148     return 0;
53149   }
53150   std::string arg2_str(jarg2);
53151   arg2 = &arg2_str;
53152   {
53153     try {
53154       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53155     } catch (std::out_of_range& e) {
53156       {
53157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53158       };
53159     } catch (std::exception& e) {
53160       {
53161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53162       };
53163     } catch (...) {
53164       {
53165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53166       };
53167     }
53168   }
53169   jresult = new Dali::Window((const Dali::Window &)result);
53170
53171   //argout typemap for const std::string&
53172
53173   return jresult;
53174 }
53175
53176
53177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53178   void * jresult ;
53179   Dali::PositionSize arg1 ;
53180   std::string *arg2 = 0 ;
53181   std::string *arg3 = 0 ;
53182   bool arg4 ;
53183   Dali::PositionSize *argp1 ;
53184   Dali::Window result;
53185
53186   argp1 = (Dali::PositionSize *)jarg1;
53187   if (!argp1) {
53188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53189     return 0;
53190   }
53191   arg1 = *argp1;
53192   if (!jarg2) {
53193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53194     return 0;
53195   }
53196   std::string arg2_str(jarg2);
53197   arg2 = &arg2_str;
53198   if (!jarg3) {
53199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53200     return 0;
53201   }
53202   std::string arg3_str(jarg3);
53203   arg3 = &arg3_str;
53204   arg4 = jarg4 ? true : false;
53205   {
53206     try {
53207       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53208     } catch (std::out_of_range& e) {
53209       {
53210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53211       };
53212     } catch (std::exception& e) {
53213       {
53214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53215       };
53216     } catch (...) {
53217       {
53218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53219       };
53220     }
53221   }
53222   jresult = new Dali::Window((const Dali::Window &)result);
53223
53224   //argout typemap for const std::string&
53225
53226
53227   //argout typemap for const std::string&
53228
53229   return jresult;
53230 }
53231
53232
53233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53234   void * jresult ;
53235   Dali::PositionSize arg1 ;
53236   std::string *arg2 = 0 ;
53237   std::string *arg3 = 0 ;
53238   Dali::PositionSize *argp1 ;
53239   Dali::Window result;
53240
53241   argp1 = (Dali::PositionSize *)jarg1;
53242   if (!argp1) {
53243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53244     return 0;
53245   }
53246   arg1 = *argp1;
53247   if (!jarg2) {
53248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53249     return 0;
53250   }
53251   std::string arg2_str(jarg2);
53252   arg2 = &arg2_str;
53253   if (!jarg3) {
53254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53255     return 0;
53256   }
53257   std::string arg3_str(jarg3);
53258   arg3 = &arg3_str;
53259   {
53260     try {
53261       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53262     } catch (std::out_of_range& e) {
53263       {
53264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53265       };
53266     } catch (std::exception& e) {
53267       {
53268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53269       };
53270     } catch (...) {
53271       {
53272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53273       };
53274     }
53275   }
53276   jresult = new Dali::Window((const Dali::Window &)result);
53277
53278   //argout typemap for const std::string&
53279
53280
53281   //argout typemap for const std::string&
53282
53283   return jresult;
53284 }
53285
53286
53287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53288   void * jresult ;
53289   Dali::Window *result = 0 ;
53290
53291   {
53292     try {
53293       result = (Dali::Window *)new Dali::Window();
53294     } catch (std::out_of_range& e) {
53295       {
53296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53297       };
53298     } catch (std::exception& e) {
53299       {
53300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53301       };
53302     } catch (...) {
53303       {
53304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53305       };
53306     }
53307   }
53308   jresult = (void *)result;
53309   return jresult;
53310 }
53311
53312
53313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53314   Dali::Window *arg1 = (Dali::Window *) 0 ;
53315
53316   arg1 = (Dali::Window *)jarg1;
53317   {
53318     try {
53319       delete arg1;
53320     } catch (std::out_of_range& e) {
53321       {
53322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53323       };
53324     } catch (std::exception& e) {
53325       {
53326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53327       };
53328     } catch (...) {
53329       {
53330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53331       };
53332     }
53333   }
53334 }
53335
53336
53337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53338   void * jresult ;
53339   Dali::Window *arg1 = 0 ;
53340   Dali::Window *result = 0 ;
53341
53342   arg1 = (Dali::Window *)jarg1;
53343   if (!arg1) {
53344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53345     return 0;
53346   }
53347   {
53348     try {
53349       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53350     } catch (std::out_of_range& e) {
53351       {
53352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53353       };
53354     } catch (std::exception& e) {
53355       {
53356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53357       };
53358     } catch (...) {
53359       {
53360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53361       };
53362     }
53363   }
53364   jresult = (void *)result;
53365   return jresult;
53366 }
53367
53368
53369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53370   void * jresult ;
53371   Dali::Window *arg1 = (Dali::Window *) 0 ;
53372   Dali::Window *arg2 = 0 ;
53373   Dali::Window *result = 0 ;
53374
53375   arg1 = (Dali::Window *)jarg1;
53376   arg2 = (Dali::Window *)jarg2;
53377   if (!arg2) {
53378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53379     return 0;
53380   }
53381   {
53382     try {
53383       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53384     } catch (std::out_of_range& e) {
53385       {
53386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53387       };
53388     } catch (std::exception& e) {
53389       {
53390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53391       };
53392     } catch (...) {
53393       {
53394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53395       };
53396     }
53397   }
53398   jresult = (void *)result;
53399   return jresult;
53400 }
53401
53402
53403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53404   Dali::Window *arg1 = (Dali::Window *) 0 ;
53405   Dali::Window::IndicatorVisibleMode arg2 ;
53406
53407   arg1 = (Dali::Window *)jarg1;
53408   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53409   {
53410     try {
53411       (arg1)->ShowIndicator(arg2);
53412     } catch (std::out_of_range& e) {
53413       {
53414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53415       };
53416     } catch (std::exception& e) {
53417       {
53418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53419       };
53420     } catch (...) {
53421       {
53422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53423       };
53424     }
53425   }
53426 }
53427
53428
53429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53430   Dali::Window *arg1 = (Dali::Window *) 0 ;
53431   Dali::Window::IndicatorBgOpacity arg2 ;
53432
53433   arg1 = (Dali::Window *)jarg1;
53434   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53435   {
53436     try {
53437       (arg1)->SetIndicatorBgOpacity(arg2);
53438     } catch (std::out_of_range& e) {
53439       {
53440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53441       };
53442     } catch (std::exception& e) {
53443       {
53444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53445       };
53446     } catch (...) {
53447       {
53448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53449       };
53450     }
53451   }
53452 }
53453
53454
53455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53456   Dali::Window *arg1 = (Dali::Window *) 0 ;
53457   Dali::Window::WindowOrientation arg2 ;
53458
53459   arg1 = (Dali::Window *)jarg1;
53460   arg2 = (Dali::Window::WindowOrientation)jarg2;
53461   {
53462     try {
53463       (arg1)->RotateIndicator(arg2);
53464     } catch (std::out_of_range& e) {
53465       {
53466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53467       };
53468     } catch (std::exception& e) {
53469       {
53470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53471       };
53472     } catch (...) {
53473       {
53474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53475       };
53476     }
53477   }
53478 }
53479
53480
53481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53482   Dali::Window *arg1 = (Dali::Window *) 0 ;
53483   std::string arg2 ;
53484   std::string arg3 ;
53485
53486   arg1 = (Dali::Window *)jarg1;
53487   if (!jarg2) {
53488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53489     return ;
53490   }
53491   (&arg2)->assign(jarg2);
53492   if (!jarg3) {
53493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53494     return ;
53495   }
53496   (&arg3)->assign(jarg3);
53497   {
53498     try {
53499       (arg1)->SetClass(arg2,arg3);
53500     } catch (std::out_of_range& e) {
53501       {
53502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53503       };
53504     } catch (std::exception& e) {
53505       {
53506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53507       };
53508     } catch (...) {
53509       {
53510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53511       };
53512     }
53513   }
53514 }
53515
53516
53517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53518   Dali::Window *arg1 = (Dali::Window *) 0 ;
53519
53520   arg1 = (Dali::Window *)jarg1;
53521   {
53522     try {
53523       (arg1)->Raise();
53524     } catch (std::out_of_range& e) {
53525       {
53526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53527       };
53528     } catch (std::exception& e) {
53529       {
53530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53531       };
53532     } catch (...) {
53533       {
53534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53535       };
53536     }
53537   }
53538 }
53539
53540
53541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
53542   Dali::Window *arg1 = (Dali::Window *) 0 ;
53543
53544   arg1 = (Dali::Window *)jarg1;
53545   {
53546     try {
53547       (arg1)->Lower();
53548     } catch (std::out_of_range& e) {
53549       {
53550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53551       };
53552     } catch (std::exception& e) {
53553       {
53554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53555       };
53556     } catch (...) {
53557       {
53558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53559       };
53560     }
53561   }
53562 }
53563
53564
53565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53566   Dali::Window *arg1 = (Dali::Window *) 0 ;
53567
53568   arg1 = (Dali::Window *)jarg1;
53569   {
53570     try {
53571       (arg1)->Activate();
53572     } catch (std::out_of_range& e) {
53573       {
53574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53575       };
53576     } catch (std::exception& e) {
53577       {
53578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53579       };
53580     } catch (...) {
53581       {
53582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53583       };
53584     }
53585   }
53586 }
53587
53588
53589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53590   Dali::Window *arg1 = (Dali::Window *) 0 ;
53591   Dali::Window::WindowOrientation arg2 ;
53592
53593   arg1 = (Dali::Window *)jarg1;
53594   arg2 = (Dali::Window::WindowOrientation)jarg2;
53595   {
53596     try {
53597       (arg1)->AddAvailableOrientation(arg2);
53598     } catch (std::out_of_range& e) {
53599       {
53600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53601       };
53602     } catch (std::exception& e) {
53603       {
53604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53605       };
53606     } catch (...) {
53607       {
53608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53609       };
53610     }
53611   }
53612 }
53613
53614
53615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53616   Dali::Window *arg1 = (Dali::Window *) 0 ;
53617   Dali::Window::WindowOrientation arg2 ;
53618
53619   arg1 = (Dali::Window *)jarg1;
53620   arg2 = (Dali::Window::WindowOrientation)jarg2;
53621   {
53622     try {
53623       (arg1)->RemoveAvailableOrientation(arg2);
53624     } catch (std::out_of_range& e) {
53625       {
53626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53627       };
53628     } catch (std::exception& e) {
53629       {
53630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53631       };
53632     } catch (...) {
53633       {
53634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53635       };
53636     }
53637   }
53638 }
53639
53640
53641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53642   Dali::Window *arg1 = (Dali::Window *) 0 ;
53643   Dali::Window::WindowOrientation arg2 ;
53644
53645   arg1 = (Dali::Window *)jarg1;
53646   arg2 = (Dali::Window::WindowOrientation)jarg2;
53647   {
53648     try {
53649       (arg1)->SetPreferredOrientation(arg2);
53650     } catch (std::out_of_range& e) {
53651       {
53652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53653       };
53654     } catch (std::exception& e) {
53655       {
53656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53657       };
53658     } catch (...) {
53659       {
53660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53661       };
53662     }
53663   }
53664 }
53665
53666
53667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53668   int jresult ;
53669   Dali::Window *arg1 = (Dali::Window *) 0 ;
53670   Dali::Window::WindowOrientation result;
53671
53672   arg1 = (Dali::Window *)jarg1;
53673   {
53674     try {
53675       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
53676     } catch (std::out_of_range& e) {
53677       {
53678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53679       };
53680     } catch (std::exception& e) {
53681       {
53682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53683       };
53684     } catch (...) {
53685       {
53686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53687       };
53688     }
53689   }
53690   jresult = (int)result;
53691   return jresult;
53692 }
53693
53694
53695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
53696   void * jresult ;
53697   Dali::Window *arg1 = (Dali::Window *) 0 ;
53698   Dali::DragAndDropDetector result;
53699
53700   arg1 = (Dali::Window *)jarg1;
53701   {
53702     try {
53703       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
53704     } catch (std::out_of_range& e) {
53705       {
53706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53707       };
53708     } catch (std::exception& e) {
53709       {
53710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53711       };
53712     } catch (...) {
53713       {
53714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53715       };
53716     }
53717   }
53718   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
53719   return jresult;
53720 }
53721
53722
53723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
53724   void * jresult ;
53725   Dali::Window *arg1 = (Dali::Window *) 0 ;
53726   Dali::Any result;
53727
53728   arg1 = (Dali::Window *)jarg1;
53729   {
53730     try {
53731       result = ((Dali::Window const *)arg1)->GetNativeHandle();
53732     } catch (std::out_of_range& e) {
53733       {
53734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53735       };
53736     } catch (std::exception& e) {
53737       {
53738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53739       };
53740     } catch (...) {
53741       {
53742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53743       };
53744     }
53745   }
53746   jresult = new Dali::Any((const Dali::Any &)result);
53747   return jresult;
53748 }
53749
53750
53751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_IndicatorVisibilityChangedSignal(void * jarg1) {
53752   void * jresult ;
53753   Dali::Window *arg1 = (Dali::Window *) 0 ;
53754   Dali::Window::IndicatorSignalType *result = 0 ;
53755
53756   arg1 = (Dali::Window *)jarg1;
53757   {
53758     try {
53759       result = (Dali::Window::IndicatorSignalType *) &(arg1)->IndicatorVisibilityChangedSignal();
53760     } catch (std::out_of_range& e) {
53761       {
53762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53763       };
53764     } catch (std::exception& e) {
53765       {
53766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53767       };
53768     } catch (...) {
53769       {
53770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53771       };
53772     }
53773   }
53774   jresult = (void *)result;
53775   return jresult;
53776 }
53777
53778
53779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
53780   void * jresult ;
53781   Dali::Application result;
53782
53783   {
53784     try {
53785       result = Dali::Application::New();
53786     } catch (std::out_of_range& e) {
53787       {
53788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53789       };
53790     } catch (std::exception& e) {
53791       {
53792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53793       };
53794     } catch (...) {
53795       {
53796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53797       };
53798     }
53799   }
53800   jresult = new Dali::Application((const Dali::Application &)result);
53801   return jresult;
53802 }
53803
53804
53805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
53806   void * jresult ;
53807   int *arg1 = (int *) 0 ;
53808   char ***arg2 ;
53809   Dali::Application result;
53810
53811   {
53812     // Todo generate argv data from the C# args
53813     char **array;         // two dimensional array
53814     int numStrings = 1;     // number of strings
53815     int stringLength = 30;      // max string length.
53816     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
53817     argV = array;
53818
53819     // allocate the string data
53820     for( int i=0; i < numStrings; i++)
53821     {
53822       array[i]=(char *)malloc( stringLength * sizeof(char *) );
53823     }
53824     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
53825
53826     strcpy( array[0], "dali-csharp-app");
53827
53828     arg1 = &argC;
53829     arg2 = &argV;
53830   }
53831   {
53832     try {
53833       result = Dali::Application::New(arg1,arg2);
53834     } catch (std::out_of_range& e) {
53835       {
53836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53837       };
53838     } catch (std::exception& e) {
53839       {
53840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53841       };
53842     } catch (...) {
53843       {
53844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53845       };
53846     }
53847   }
53848   jresult = new Dali::Application((const Dali::Application &)result);
53849   return jresult;
53850 }
53851
53852
53853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
53854   void * jresult ;
53855   int *arg1 = (int *) 0 ;
53856   char ***arg2 ;
53857   std::string *arg3 = 0 ;
53858   Dali::Application result;
53859
53860   {
53861     // Todo generate argv data from the C# args
53862     char **array;         // two dimensional array
53863     int numStrings = 1;     // number of strings
53864     int stringLength = 30;      // max string length.
53865     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
53866     argV = array;
53867
53868     // allocate the string data
53869     for( int i=0; i < numStrings; i++)
53870     {
53871       array[i]=(char *)malloc( stringLength * sizeof(char *) );
53872     }
53873     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
53874
53875     strcpy( array[0], "dali-csharp-app");
53876
53877     arg1 = &argC;
53878     arg2 = &argV;
53879   }
53880   if (!jarg3) {
53881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53882     return 0;
53883   }
53884   std::string arg3_str(jarg3);
53885   arg3 = &arg3_str;
53886   {
53887     try {
53888       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
53889     } catch (std::out_of_range& e) {
53890       {
53891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53892       };
53893     } catch (std::exception& e) {
53894       {
53895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53896       };
53897     } catch (...) {
53898       {
53899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53900       };
53901     }
53902   }
53903   jresult = new Dali::Application((const Dali::Application &)result);
53904
53905   //argout typemap for const std::string&
53906
53907   return jresult;
53908 }
53909
53910
53911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
53912   void * jresult ;
53913   int *arg1 = (int *) 0 ;
53914   char ***arg2 ;
53915   std::string *arg3 = 0 ;
53916   Dali::Application::WINDOW_MODE arg4 ;
53917   Dali::Application result;
53918
53919   {
53920     // Todo generate argv data from the C# args
53921     char **array;         // two dimensional array
53922     int numStrings = 1;     // number of strings
53923     int stringLength = 30;      // max string length.
53924     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
53925     argV = array;
53926
53927     // allocate the string data
53928     for( int i=0; i < numStrings; i++)
53929     {
53930       array[i]=(char *)malloc( stringLength * sizeof(char *) );
53931     }
53932     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
53933
53934     strcpy( array[0], "dali-csharp-app");
53935
53936     arg1 = &argC;
53937     arg2 = &argV;
53938   }
53939   if (!jarg3) {
53940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53941     return 0;
53942   }
53943   std::string arg3_str(jarg3);
53944   arg3 = &arg3_str;
53945   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
53946   {
53947     try {
53948       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
53949     } catch (std::out_of_range& e) {
53950       {
53951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53952       };
53953     } catch (std::exception& e) {
53954       {
53955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53956       };
53957     } catch (...) {
53958       {
53959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53960       };
53961     }
53962   }
53963   jresult = new Dali::Application((const Dali::Application &)result);
53964
53965   //argout typemap for const std::string&
53966
53967   return jresult;
53968 }
53969
53970
53971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
53972   void * jresult ;
53973   Dali::Application *result = 0 ;
53974
53975   {
53976     try {
53977       result = (Dali::Application *)new Dali::Application();
53978     } catch (std::out_of_range& e) {
53979       {
53980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53981       };
53982     } catch (std::exception& e) {
53983       {
53984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53985       };
53986     } catch (...) {
53987       {
53988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53989       };
53990     }
53991   }
53992   jresult = (void *)result;
53993   return jresult;
53994 }
53995
53996
53997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
53998   void * jresult ;
53999   Dali::Application *arg1 = 0 ;
54000   Dali::Application *result = 0 ;
54001
54002   arg1 = (Dali::Application *)jarg1;
54003   if (!arg1) {
54004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54005     return 0;
54006   }
54007   {
54008     try {
54009       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54010     } catch (std::out_of_range& e) {
54011       {
54012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54013       };
54014     } catch (std::exception& e) {
54015       {
54016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54017       };
54018     } catch (...) {
54019       {
54020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54021       };
54022     }
54023   }
54024   jresult = (void *)result;
54025   return jresult;
54026 }
54027
54028
54029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54030   void * jresult ;
54031   Dali::Application *arg1 = (Dali::Application *) 0 ;
54032   Dali::Application *arg2 = 0 ;
54033   Dali::Application *result = 0 ;
54034
54035   arg1 = (Dali::Application *)jarg1;
54036   arg2 = (Dali::Application *)jarg2;
54037   if (!arg2) {
54038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54039     return 0;
54040   }
54041   {
54042     try {
54043       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
54044     } catch (std::out_of_range& e) {
54045       {
54046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54047       };
54048     } catch (std::exception& e) {
54049       {
54050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54051       };
54052     } catch (...) {
54053       {
54054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54055       };
54056     }
54057   }
54058   jresult = (void *)result;
54059   return jresult;
54060 }
54061
54062
54063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54064   Dali::Application *arg1 = (Dali::Application *) 0 ;
54065
54066   arg1 = (Dali::Application *)jarg1;
54067   {
54068     try {
54069       delete arg1;
54070     } catch (std::out_of_range& e) {
54071       {
54072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54073       };
54074     } catch (std::exception& e) {
54075       {
54076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54077       };
54078     } catch (...) {
54079       {
54080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54081       };
54082     }
54083   }
54084 }
54085
54086
54087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54088   Dali::Application *arg1 = (Dali::Application *) 0 ;
54089
54090   arg1 = (Dali::Application *)jarg1;
54091   {
54092     try {
54093       (arg1)->MainLoop();
54094     } catch (std::out_of_range& e) {
54095       {
54096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54097       };
54098     } catch (std::exception& e) {
54099       {
54100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54101       };
54102     } catch (...) {
54103       {
54104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54105       };
54106     }
54107   }
54108 }
54109
54110
54111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54112   Dali::Application *arg1 = (Dali::Application *) 0 ;
54113   Configuration::ContextLoss arg2 ;
54114   Configuration::ContextLoss *argp2 ;
54115
54116   arg1 = (Dali::Application *)jarg1;
54117   argp2 = (Configuration::ContextLoss *)jarg2;
54118   if (!argp2) {
54119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54120     return ;
54121   }
54122   arg2 = *argp2;
54123   {
54124     try {
54125       (arg1)->MainLoop(arg2);
54126     } catch (std::out_of_range& e) {
54127       {
54128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54129       };
54130     } catch (std::exception& e) {
54131       {
54132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54133       };
54134     } catch (...) {
54135       {
54136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54137       };
54138     }
54139   }
54140 }
54141
54142
54143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54144   Dali::Application *arg1 = (Dali::Application *) 0 ;
54145
54146   arg1 = (Dali::Application *)jarg1;
54147   {
54148     try {
54149       (arg1)->Lower();
54150     } catch (std::out_of_range& e) {
54151       {
54152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54153       };
54154     } catch (std::exception& e) {
54155       {
54156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54157       };
54158     } catch (...) {
54159       {
54160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54161       };
54162     }
54163   }
54164 }
54165
54166
54167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54168   Dali::Application *arg1 = (Dali::Application *) 0 ;
54169
54170   arg1 = (Dali::Application *)jarg1;
54171   {
54172     try {
54173       (arg1)->Quit();
54174     } catch (std::out_of_range& e) {
54175       {
54176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54177       };
54178     } catch (std::exception& e) {
54179       {
54180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54181       };
54182     } catch (...) {
54183       {
54184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54185       };
54186     }
54187   }
54188 }
54189
54190
54191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54192   unsigned int jresult ;
54193   Dali::Application *arg1 = (Dali::Application *) 0 ;
54194   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54195   bool result;
54196
54197   arg1 = (Dali::Application *)jarg1;
54198   arg2 = (Dali::CallbackBase *)jarg2;
54199   {
54200     try {
54201       result = (bool)(arg1)->AddIdle(arg2);
54202     } catch (std::out_of_range& e) {
54203       {
54204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54205       };
54206     } catch (std::exception& e) {
54207       {
54208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54209       };
54210     } catch (...) {
54211       {
54212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54213       };
54214     }
54215   }
54216   jresult = result;
54217   return jresult;
54218 }
54219
54220
54221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54222   void * jresult ;
54223   Dali::Application *arg1 = (Dali::Application *) 0 ;
54224   Dali::Window result;
54225
54226   arg1 = (Dali::Application *)jarg1;
54227   {
54228     try {
54229       result = (arg1)->GetWindow();
54230     } catch (std::out_of_range& e) {
54231       {
54232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54233       };
54234     } catch (std::exception& e) {
54235       {
54236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54237       };
54238     } catch (...) {
54239       {
54240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54241       };
54242     }
54243   }
54244   jresult = new Dali::Window((const Dali::Window &)result);
54245   return jresult;
54246 }
54247
54248
54249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54250   Dali::Application *arg1 = (Dali::Application *) 0 ;
54251   Dali::PositionSize arg2 ;
54252   std::string *arg3 = 0 ;
54253   Dali::PositionSize *argp2 ;
54254
54255   arg1 = (Dali::Application *)jarg1;
54256   argp2 = (Dali::PositionSize *)jarg2;
54257   if (!argp2) {
54258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54259     return ;
54260   }
54261   arg2 = *argp2;
54262   if (!jarg3) {
54263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54264     return ;
54265   }
54266   std::string arg3_str(jarg3);
54267   arg3 = &arg3_str;
54268   {
54269     try {
54270       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54271     } catch (std::out_of_range& e) {
54272       {
54273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54274       };
54275     } catch (std::exception& e) {
54276       {
54277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54278       };
54279     } catch (...) {
54280       {
54281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54282       };
54283     }
54284   }
54285
54286   //argout typemap for const std::string&
54287
54288 }
54289
54290
54291 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54292   char * jresult ;
54293   std::string result;
54294
54295   {
54296     try {
54297       result = Dali::Application::GetResourcePath();
54298     } catch (std::out_of_range& e) {
54299       {
54300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54301       };
54302     } catch (std::exception& e) {
54303       {
54304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54305       };
54306     } catch (...) {
54307       {
54308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54309       };
54310     }
54311   }
54312   jresult = SWIG_csharp_string_callback((&result)->c_str());
54313   return jresult;
54314 }
54315
54316
54317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54318   Dali::Application *arg1 = (Dali::Application *) 0 ;
54319   Dali::ViewMode arg2 ;
54320
54321   arg1 = (Dali::Application *)jarg1;
54322   arg2 = (Dali::ViewMode)jarg2;
54323   {
54324     try {
54325       (arg1)->SetViewMode(arg2);
54326     } catch (std::out_of_range& e) {
54327       {
54328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54329       };
54330     } catch (std::exception& e) {
54331       {
54332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54333       };
54334     } catch (...) {
54335       {
54336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54337       };
54338     }
54339   }
54340 }
54341
54342
54343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54344   int jresult ;
54345   Dali::Application *arg1 = (Dali::Application *) 0 ;
54346   Dali::ViewMode result;
54347
54348   arg1 = (Dali::Application *)jarg1;
54349   {
54350     try {
54351       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54352     } catch (std::out_of_range& e) {
54353       {
54354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54355       };
54356     } catch (std::exception& e) {
54357       {
54358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54359       };
54360     } catch (...) {
54361       {
54362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54363       };
54364     }
54365   }
54366   jresult = (int)result;
54367   return jresult;
54368 }
54369
54370
54371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54372   Dali::Application *arg1 = (Dali::Application *) 0 ;
54373   float arg2 ;
54374
54375   arg1 = (Dali::Application *)jarg1;
54376   arg2 = (float)jarg2;
54377   {
54378     try {
54379       (arg1)->SetStereoBase(arg2);
54380     } catch (std::out_of_range& e) {
54381       {
54382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54383       };
54384     } catch (std::exception& e) {
54385       {
54386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54387       };
54388     } catch (...) {
54389       {
54390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54391       };
54392     }
54393   }
54394 }
54395
54396
54397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54398   float jresult ;
54399   Dali::Application *arg1 = (Dali::Application *) 0 ;
54400   float result;
54401
54402   arg1 = (Dali::Application *)jarg1;
54403   {
54404     try {
54405       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54406     } catch (std::out_of_range& e) {
54407       {
54408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54409       };
54410     } catch (std::exception& e) {
54411       {
54412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54413       };
54414     } catch (...) {
54415       {
54416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54417       };
54418     }
54419   }
54420   jresult = result;
54421   return jresult;
54422 }
54423
54424
54425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54426   void * jresult ;
54427   Dali::Application *arg1 = (Dali::Application *) 0 ;
54428   Dali::Application::AppSignalType *result = 0 ;
54429
54430   arg1 = (Dali::Application *)jarg1;
54431   {
54432     try {
54433       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54434     } catch (std::out_of_range& e) {
54435       {
54436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54437       };
54438     } catch (std::exception& e) {
54439       {
54440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54441       };
54442     } catch (...) {
54443       {
54444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54445       };
54446     }
54447   }
54448   jresult = (void *)result;
54449   return jresult;
54450 }
54451
54452
54453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54454   void * jresult ;
54455   Dali::Application *arg1 = (Dali::Application *) 0 ;
54456   Dali::Application::AppSignalType *result = 0 ;
54457
54458   arg1 = (Dali::Application *)jarg1;
54459   {
54460     try {
54461       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54462     } catch (std::out_of_range& e) {
54463       {
54464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54465       };
54466     } catch (std::exception& e) {
54467       {
54468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54469       };
54470     } catch (...) {
54471       {
54472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54473       };
54474     }
54475   }
54476   jresult = (void *)result;
54477   return jresult;
54478 }
54479
54480
54481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54482   void * jresult ;
54483   Dali::Application *arg1 = (Dali::Application *) 0 ;
54484   Dali::Application::AppSignalType *result = 0 ;
54485
54486   arg1 = (Dali::Application *)jarg1;
54487   {
54488     try {
54489       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54490     } catch (std::out_of_range& e) {
54491       {
54492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54493       };
54494     } catch (std::exception& e) {
54495       {
54496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54497       };
54498     } catch (...) {
54499       {
54500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54501       };
54502     }
54503   }
54504   jresult = (void *)result;
54505   return jresult;
54506 }
54507
54508
54509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
54510   void * jresult ;
54511   Dali::Application *arg1 = (Dali::Application *) 0 ;
54512   Dali::Application::AppSignalType *result = 0 ;
54513
54514   arg1 = (Dali::Application *)jarg1;
54515   {
54516     try {
54517       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
54518     } catch (std::out_of_range& e) {
54519       {
54520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54521       };
54522     } catch (std::exception& e) {
54523       {
54524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54525       };
54526     } catch (...) {
54527       {
54528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54529       };
54530     }
54531   }
54532   jresult = (void *)result;
54533   return jresult;
54534 }
54535
54536
54537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
54538   void * jresult ;
54539   Dali::Application *arg1 = (Dali::Application *) 0 ;
54540   Dali::Application::AppSignalType *result = 0 ;
54541
54542   arg1 = (Dali::Application *)jarg1;
54543   {
54544     try {
54545       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
54546     } catch (std::out_of_range& e) {
54547       {
54548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54549       };
54550     } catch (std::exception& e) {
54551       {
54552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54553       };
54554     } catch (...) {
54555       {
54556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54557       };
54558     }
54559   }
54560   jresult = (void *)result;
54561   return jresult;
54562 }
54563
54564
54565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
54566   void * jresult ;
54567   Dali::Application *arg1 = (Dali::Application *) 0 ;
54568   Dali::Application::AppSignalType *result = 0 ;
54569
54570   arg1 = (Dali::Application *)jarg1;
54571   {
54572     try {
54573       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
54574     } catch (std::out_of_range& e) {
54575       {
54576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54577       };
54578     } catch (std::exception& e) {
54579       {
54580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54581       };
54582     } catch (...) {
54583       {
54584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54585       };
54586     }
54587   }
54588   jresult = (void *)result;
54589   return jresult;
54590 }
54591
54592
54593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
54594   void * jresult ;
54595   Dali::Application *arg1 = (Dali::Application *) 0 ;
54596   Dali::Application::AppControlSignalType *result = 0 ;
54597
54598   arg1 = (Dali::Application *)jarg1;
54599   {
54600     try {
54601       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
54602     } catch (std::out_of_range& e) {
54603       {
54604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54605       };
54606     } catch (std::exception& e) {
54607       {
54608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54609       };
54610     } catch (...) {
54611       {
54612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54613       };
54614     }
54615   }
54616   jresult = (void *)result;
54617   return jresult;
54618 }
54619
54620
54621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
54622   void * jresult ;
54623   Dali::Application *arg1 = (Dali::Application *) 0 ;
54624   Dali::Application::AppSignalType *result = 0 ;
54625
54626   arg1 = (Dali::Application *)jarg1;
54627   {
54628     try {
54629       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
54630     } catch (std::out_of_range& e) {
54631       {
54632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54633       };
54634     } catch (std::exception& e) {
54635       {
54636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54637       };
54638     } catch (...) {
54639       {
54640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54641       };
54642     }
54643   }
54644   jresult = (void *)result;
54645   return jresult;
54646 }
54647
54648
54649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
54650   void * jresult ;
54651   Dali::Application *arg1 = (Dali::Application *) 0 ;
54652   Dali::Application::AppSignalType *result = 0 ;
54653
54654   arg1 = (Dali::Application *)jarg1;
54655   {
54656     try {
54657       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
54658     } catch (std::out_of_range& e) {
54659       {
54660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54661       };
54662     } catch (std::exception& e) {
54663       {
54664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54665       };
54666     } catch (...) {
54667       {
54668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54669       };
54670     }
54671   }
54672   jresult = (void *)result;
54673   return jresult;
54674 }
54675
54676
54677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
54678   void * jresult ;
54679   Dali::Application *arg1 = (Dali::Application *) 0 ;
54680   Dali::Application::AppSignalType *result = 0 ;
54681
54682   arg1 = (Dali::Application *)jarg1;
54683   {
54684     try {
54685       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
54686     } catch (std::out_of_range& e) {
54687       {
54688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54689       };
54690     } catch (std::exception& e) {
54691       {
54692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54693       };
54694     } catch (...) {
54695       {
54696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54697       };
54698     }
54699   }
54700   jresult = (void *)result;
54701   return jresult;
54702 }
54703
54704
54705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
54706   void * jresult ;
54707   Dali::Application *arg1 = (Dali::Application *) 0 ;
54708   Dali::Application::AppSignalType *result = 0 ;
54709
54710   arg1 = (Dali::Application *)jarg1;
54711   {
54712     try {
54713       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
54714     } catch (std::out_of_range& e) {
54715       {
54716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54717       };
54718     } catch (std::exception& e) {
54719       {
54720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54721       };
54722     } catch (...) {
54723       {
54724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54725       };
54726     }
54727   }
54728   jresult = (void *)result;
54729   return jresult;
54730 }
54731
54732
54733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
54734   unsigned int jresult ;
54735   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54736   bool result;
54737
54738   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54739   {
54740     try {
54741       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
54742     } catch (std::out_of_range& e) {
54743       {
54744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54745       };
54746     } catch (std::exception& e) {
54747       {
54748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54749       };
54750     } catch (...) {
54751       {
54752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54753       };
54754     }
54755   }
54756   jresult = result;
54757   return jresult;
54758 }
54759
54760
54761 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
54762   unsigned long jresult ;
54763   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54764   std::size_t result;
54765
54766   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54767   {
54768     try {
54769       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
54770     } catch (std::out_of_range& e) {
54771       {
54772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54773       };
54774     } catch (std::exception& e) {
54775       {
54776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54777       };
54778     } catch (...) {
54779       {
54780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54781       };
54782     }
54783   }
54784   jresult = (unsigned long)result;
54785   return jresult;
54786 }
54787
54788
54789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
54790   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54791   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
54792
54793   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54794   arg2 = (void (*)(Dali::Application &))jarg2;
54795   {
54796     try {
54797       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
54798     } catch (std::out_of_range& e) {
54799       {
54800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54801       };
54802     } catch (std::exception& e) {
54803       {
54804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54805       };
54806     } catch (...) {
54807       {
54808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54809       };
54810     }
54811   }
54812 }
54813
54814
54815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
54816   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54817   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
54818
54819   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54820   arg2 = (void (*)(Dali::Application &))jarg2;
54821   {
54822     try {
54823       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
54824     } catch (std::out_of_range& e) {
54825       {
54826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54827       };
54828     } catch (std::exception& e) {
54829       {
54830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54831       };
54832     } catch (...) {
54833       {
54834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54835       };
54836     }
54837   }
54838 }
54839
54840
54841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
54842   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54843   Dali::Application *arg2 = 0 ;
54844
54845   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54846   arg2 = (Dali::Application *)jarg2;
54847   if (!arg2) {
54848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
54849     return ;
54850   }
54851   {
54852     try {
54853       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
54854     } catch (std::out_of_range& e) {
54855       {
54856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54857       };
54858     } catch (std::exception& e) {
54859       {
54860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54861       };
54862     } catch (...) {
54863       {
54864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54865       };
54866     }
54867   }
54868 }
54869
54870
54871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
54872   void * jresult ;
54873   Dali::Signal< void (Dali::Application &) > *result = 0 ;
54874
54875   {
54876     try {
54877       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
54878     } catch (std::out_of_range& e) {
54879       {
54880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54881       };
54882     } catch (std::exception& e) {
54883       {
54884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54885       };
54886     } catch (...) {
54887       {
54888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54889       };
54890     }
54891   }
54892   jresult = (void *)result;
54893   return jresult;
54894 }
54895
54896
54897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
54898   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54899
54900   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54901   {
54902     try {
54903       delete arg1;
54904     } catch (std::out_of_range& e) {
54905       {
54906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54907       };
54908     } catch (std::exception& e) {
54909       {
54910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54911       };
54912     } catch (...) {
54913       {
54914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54915       };
54916     }
54917   }
54918 }
54919
54920
54921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
54922   unsigned int jresult ;
54923   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54924   bool result;
54925
54926   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54927   {
54928     try {
54929       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
54930     } catch (std::out_of_range& e) {
54931       {
54932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54933       };
54934     } catch (std::exception& e) {
54935       {
54936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54937       };
54938     } catch (...) {
54939       {
54940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54941       };
54942     }
54943   }
54944   jresult = result;
54945   return jresult;
54946 }
54947
54948
54949 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
54950   unsigned long jresult ;
54951   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54952   std::size_t result;
54953
54954   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54955   {
54956     try {
54957       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
54958     } catch (std::out_of_range& e) {
54959       {
54960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54961       };
54962     } catch (std::exception& e) {
54963       {
54964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54965       };
54966     } catch (...) {
54967       {
54968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54969       };
54970     }
54971   }
54972   jresult = (unsigned long)result;
54973   return jresult;
54974 }
54975
54976
54977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
54978   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54979   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
54980
54981   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54982   arg2 = (void (*)(Dali::Application &,void *))jarg2;
54983   {
54984     try {
54985       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
54986     } catch (std::out_of_range& e) {
54987       {
54988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54989       };
54990     } catch (std::exception& e) {
54991       {
54992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54993       };
54994     } catch (...) {
54995       {
54996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54997       };
54998     }
54999   }
55000 }
55001
55002
55003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55004   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55005   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55006
55007   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55008   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55009   {
55010     try {
55011       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55012     } catch (std::out_of_range& e) {
55013       {
55014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55015       };
55016     } catch (std::exception& e) {
55017       {
55018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55019       };
55020     } catch (...) {
55021       {
55022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55023       };
55024     }
55025   }
55026 }
55027
55028
55029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55030   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55031   Dali::Application *arg2 = 0 ;
55032   void *arg3 = (void *) 0 ;
55033
55034   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55035   arg2 = (Dali::Application *)jarg2;
55036   if (!arg2) {
55037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55038     return ;
55039   }
55040   arg3 = jarg3;
55041   {
55042     try {
55043       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
55044     } catch (std::out_of_range& e) {
55045       {
55046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55047       };
55048     } catch (std::exception& e) {
55049       {
55050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55051       };
55052     } catch (...) {
55053       {
55054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55055       };
55056     }
55057   }
55058 }
55059
55060
55061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55062   void * jresult ;
55063   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55064
55065   {
55066     try {
55067       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55068     } catch (std::out_of_range& e) {
55069       {
55070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55071       };
55072     } catch (std::exception& e) {
55073       {
55074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55075       };
55076     } catch (...) {
55077       {
55078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55079       };
55080     }
55081   }
55082   jresult = (void *)result;
55083   return jresult;
55084 }
55085
55086
55087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55088   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55089
55090   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55091   {
55092     try {
55093       delete arg1;
55094     } catch (std::out_of_range& e) {
55095       {
55096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55097       };
55098     } catch (std::exception& e) {
55099       {
55100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55101       };
55102     } catch (...) {
55103       {
55104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55105       };
55106     }
55107   }
55108 }
55109
55110
55111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55112   void * jresult ;
55113   Dali::Signal< bool () > *result = 0 ;
55114
55115   {
55116     try {
55117       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55118     } catch (std::out_of_range& e) {
55119       {
55120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55121       };
55122     } catch (std::exception& e) {
55123       {
55124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55125       };
55126     } catch (...) {
55127       {
55128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55129       };
55130     }
55131   }
55132   jresult = (void *)result;
55133   return jresult;
55134 }
55135
55136
55137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55138   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55139
55140   arg1 = (Dali::Signal< bool () > *)jarg1;
55141   {
55142     try {
55143       delete arg1;
55144     } catch (std::out_of_range& e) {
55145       {
55146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55147       };
55148     } catch (std::exception& e) {
55149       {
55150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55151       };
55152     } catch (...) {
55153       {
55154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55155       };
55156     }
55157   }
55158 }
55159
55160
55161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55162   unsigned int jresult ;
55163   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55164   bool result;
55165
55166   arg1 = (Dali::Signal< bool () > *)jarg1;
55167   {
55168     try {
55169       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
55170     } catch (std::out_of_range& e) {
55171       {
55172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55173       };
55174     } catch (std::exception& e) {
55175       {
55176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55177       };
55178     } catch (...) {
55179       {
55180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55181       };
55182     }
55183   }
55184   jresult = result;
55185   return jresult;
55186 }
55187
55188
55189 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55190   unsigned long jresult ;
55191   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55192   std::size_t result;
55193
55194   arg1 = (Dali::Signal< bool () > *)jarg1;
55195   {
55196     try {
55197       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
55198     } catch (std::out_of_range& e) {
55199       {
55200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55201       };
55202     } catch (std::exception& e) {
55203       {
55204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55205       };
55206     } catch (...) {
55207       {
55208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55209       };
55210     }
55211   }
55212   jresult = (unsigned long)result;
55213   return jresult;
55214 }
55215
55216
55217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) {
55218   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55219   bool (*arg2)() = (bool (*)()) 0 ;
55220
55221   arg1 = (Dali::Signal< bool () > *)jarg1;
55222   arg2 = (bool (*)())jarg2;
55223   {
55224     try {
55225       (arg1)->Connect(arg2);
55226     } catch (std::out_of_range& e) {
55227       {
55228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55229       };
55230     } catch (std::exception& e) {
55231       {
55232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55233       };
55234     } catch (...) {
55235       {
55236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55237       };
55238     }
55239   }
55240 }
55241
55242
55243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55244   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55245   bool (*arg2)() = (bool (*)()) 0 ;
55246
55247   arg1 = (Dali::Signal< bool () > *)jarg1;
55248   arg2 = (bool (*)())jarg2;
55249   {
55250     try {
55251       (arg1)->Disconnect(arg2);
55252     } catch (std::out_of_range& e) {
55253       {
55254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55255       };
55256     } catch (std::exception& e) {
55257       {
55258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55259       };
55260     } catch (...) {
55261       {
55262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55263       };
55264     }
55265   }
55266 }
55267
55268
55269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
55270   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55271   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
55272   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
55273
55274   arg1 = (Dali::Signal< bool () > *)jarg1;
55275   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
55276   arg3 = (Dali::FunctorDelegate *)jarg3;
55277   {
55278     try {
55279       (arg1)->Connect(arg2,arg3);
55280     } catch (std::out_of_range& e) {
55281       {
55282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55283       };
55284     } catch (std::exception& e) {
55285       {
55286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55287       };
55288     } catch (...) {
55289       {
55290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55291       };
55292     }
55293   }
55294 }
55295
55296
55297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55298   unsigned int jresult ;
55299   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55300   bool result;
55301
55302   arg1 = (Dali::Signal< bool () > *)jarg1;
55303   {
55304     try {
55305       result = (bool)(arg1)->Emit();
55306     } catch (std::out_of_range& e) {
55307       {
55308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55309       };
55310     } catch (std::exception& e) {
55311       {
55312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55313       };
55314     } catch (...) {
55315       {
55316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55317       };
55318     }
55319   }
55320   jresult = result;
55321   return jresult;
55322 }
55323
55324
55325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55326   int jresult ;
55327   int result;
55328
55329   {
55330     try {
55331       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55332     } catch (std::out_of_range& e) {
55333       {
55334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55335       };
55336     } catch (std::exception& e) {
55337       {
55338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55339       };
55340     } catch (...) {
55341       {
55342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55343       };
55344     }
55345   }
55346   jresult = (int)result;
55347   return jresult;
55348 }
55349
55350
55351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55352   int jresult ;
55353   int result;
55354
55355   {
55356     try {
55357       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55358     } catch (std::out_of_range& e) {
55359       {
55360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55361       };
55362     } catch (std::exception& e) {
55363       {
55364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55365       };
55366     } catch (...) {
55367       {
55368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55369       };
55370     }
55371   }
55372   jresult = (int)result;
55373   return jresult;
55374 }
55375
55376
55377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55378   int jresult ;
55379   int result;
55380
55381   {
55382     try {
55383       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55384     } catch (std::out_of_range& e) {
55385       {
55386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55387       };
55388     } catch (std::exception& e) {
55389       {
55390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55391       };
55392     } catch (...) {
55393       {
55394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55395       };
55396     }
55397   }
55398   jresult = (int)result;
55399   return jresult;
55400 }
55401
55402
55403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55404   int jresult ;
55405   int result;
55406
55407   {
55408     try {
55409       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55410     } catch (std::out_of_range& e) {
55411       {
55412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55413       };
55414     } catch (std::exception& e) {
55415       {
55416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55417       };
55418     } catch (...) {
55419       {
55420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55421       };
55422     }
55423   }
55424   jresult = (int)result;
55425   return jresult;
55426 }
55427
55428
55429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55430   int jresult ;
55431   int result;
55432
55433   {
55434     try {
55435       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55436     } catch (std::out_of_range& e) {
55437       {
55438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55439       };
55440     } catch (std::exception& e) {
55441       {
55442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55443       };
55444     } catch (...) {
55445       {
55446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55447       };
55448     }
55449   }
55450   jresult = (int)result;
55451   return jresult;
55452 }
55453
55454
55455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55456   int jresult ;
55457   int result;
55458
55459   {
55460     try {
55461       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55462     } catch (std::out_of_range& e) {
55463       {
55464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55465       };
55466     } catch (std::exception& e) {
55467       {
55468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55469       };
55470     } catch (...) {
55471       {
55472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55473       };
55474     }
55475   }
55476   jresult = (int)result;
55477   return jresult;
55478 }
55479
55480
55481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55482   int jresult ;
55483   int result;
55484
55485   {
55486     try {
55487       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55488     } catch (std::out_of_range& e) {
55489       {
55490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55491       };
55492     } catch (std::exception& e) {
55493       {
55494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55495       };
55496     } catch (...) {
55497       {
55498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55499       };
55500     }
55501   }
55502   jresult = (int)result;
55503   return jresult;
55504 }
55505
55506
55507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55508   int jresult ;
55509   int result;
55510
55511   {
55512     try {
55513       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55514     } catch (std::out_of_range& e) {
55515       {
55516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55517       };
55518     } catch (std::exception& e) {
55519       {
55520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55521       };
55522     } catch (...) {
55523       {
55524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55525       };
55526     }
55527   }
55528   jresult = (int)result;
55529   return jresult;
55530 }
55531
55532
55533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55534   int jresult ;
55535   int result;
55536
55537   {
55538     try {
55539       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55540     } catch (std::out_of_range& e) {
55541       {
55542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55543       };
55544     } catch (std::exception& e) {
55545       {
55546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55547       };
55548     } catch (...) {
55549       {
55550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55551       };
55552     }
55553   }
55554   jresult = (int)result;
55555   return jresult;
55556 }
55557
55558
55559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55560   int jresult ;
55561   int result;
55562
55563   {
55564     try {
55565       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55566     } catch (std::out_of_range& e) {
55567       {
55568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55569       };
55570     } catch (std::exception& e) {
55571       {
55572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55573       };
55574     } catch (...) {
55575       {
55576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55577       };
55578     }
55579   }
55580   jresult = (int)result;
55581   return jresult;
55582 }
55583
55584
55585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55586   int jresult ;
55587   int result;
55588
55589   {
55590     try {
55591       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55592     } catch (std::out_of_range& e) {
55593       {
55594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55595       };
55596     } catch (std::exception& e) {
55597       {
55598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55599       };
55600     } catch (...) {
55601       {
55602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55603       };
55604     }
55605   }
55606   jresult = (int)result;
55607   return jresult;
55608 }
55609
55610
55611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55612   int jresult ;
55613   int result;
55614
55615   {
55616     try {
55617       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55618     } catch (std::out_of_range& e) {
55619       {
55620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55621       };
55622     } catch (std::exception& e) {
55623       {
55624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55625       };
55626     } catch (...) {
55627       {
55628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55629       };
55630     }
55631   }
55632   jresult = (int)result;
55633   return jresult;
55634 }
55635
55636
55637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55638   int jresult ;
55639   int result;
55640
55641   {
55642     try {
55643       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55644     } catch (std::out_of_range& e) {
55645       {
55646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55647       };
55648     } catch (std::exception& e) {
55649       {
55650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55651       };
55652     } catch (...) {
55653       {
55654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55655       };
55656     }
55657   }
55658   jresult = (int)result;
55659   return jresult;
55660 }
55661
55662
55663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55664   int jresult ;
55665   int result;
55666
55667   {
55668     try {
55669       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55670     } catch (std::out_of_range& e) {
55671       {
55672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55673       };
55674     } catch (std::exception& e) {
55675       {
55676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55677       };
55678     } catch (...) {
55679       {
55680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55681       };
55682     }
55683   }
55684   jresult = (int)result;
55685   return jresult;
55686 }
55687
55688
55689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55690   int jresult ;
55691   int result;
55692
55693   {
55694     try {
55695       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55696     } catch (std::out_of_range& e) {
55697       {
55698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55699       };
55700     } catch (std::exception& e) {
55701       {
55702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55703       };
55704     } catch (...) {
55705       {
55706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55707       };
55708     }
55709   }
55710   jresult = (int)result;
55711   return jresult;
55712 }
55713
55714
55715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55716   int jresult ;
55717   int result;
55718
55719   {
55720     try {
55721       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55722     } catch (std::out_of_range& e) {
55723       {
55724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55725       };
55726     } catch (std::exception& e) {
55727       {
55728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55729       };
55730     } catch (...) {
55731       {
55732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55733       };
55734     }
55735   }
55736   jresult = (int)result;
55737   return jresult;
55738 }
55739
55740
55741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55742   int jresult ;
55743   int result;
55744
55745   {
55746     try {
55747       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55748     } catch (std::out_of_range& e) {
55749       {
55750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55751       };
55752     } catch (std::exception& e) {
55753       {
55754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55755       };
55756     } catch (...) {
55757       {
55758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55759       };
55760     }
55761   }
55762   jresult = (int)result;
55763   return jresult;
55764 }
55765
55766
55767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55768   int jresult ;
55769   int result;
55770
55771   {
55772     try {
55773       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55774     } catch (std::out_of_range& e) {
55775       {
55776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55777       };
55778     } catch (std::exception& e) {
55779       {
55780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55781       };
55782     } catch (...) {
55783       {
55784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55785       };
55786     }
55787   }
55788   jresult = (int)result;
55789   return jresult;
55790 }
55791
55792
55793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55794   int jresult ;
55795   int result;
55796
55797   {
55798     try {
55799       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55800     } catch (std::out_of_range& e) {
55801       {
55802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55803       };
55804     } catch (std::exception& e) {
55805       {
55806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55807       };
55808     } catch (...) {
55809       {
55810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55811       };
55812     }
55813   }
55814   jresult = (int)result;
55815   return jresult;
55816 }
55817
55818
55819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55820   int jresult ;
55821   int result;
55822
55823   {
55824     try {
55825       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55826     } catch (std::out_of_range& e) {
55827       {
55828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55829       };
55830     } catch (std::exception& e) {
55831       {
55832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55833       };
55834     } catch (...) {
55835       {
55836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55837       };
55838     }
55839   }
55840   jresult = (int)result;
55841   return jresult;
55842 }
55843
55844
55845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
55846   int jresult ;
55847   int result;
55848
55849   {
55850     try {
55851       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
55852     } catch (std::out_of_range& e) {
55853       {
55854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55855       };
55856     } catch (std::exception& e) {
55857       {
55858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55859       };
55860     } catch (...) {
55861       {
55862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55863       };
55864     }
55865   }
55866   jresult = (int)result;
55867   return jresult;
55868 }
55869
55870
55871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
55872   int jresult ;
55873   int result;
55874
55875   {
55876     try {
55877       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
55878     } catch (std::out_of_range& e) {
55879       {
55880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55881       };
55882     } catch (std::exception& e) {
55883       {
55884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55885       };
55886     } catch (...) {
55887       {
55888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55889       };
55890     }
55891   }
55892   jresult = (int)result;
55893   return jresult;
55894 }
55895
55896
55897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
55898   int jresult ;
55899   int result;
55900
55901   {
55902     try {
55903       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
55904     } catch (std::out_of_range& e) {
55905       {
55906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55907       };
55908     } catch (std::exception& e) {
55909       {
55910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55911       };
55912     } catch (...) {
55913       {
55914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55915       };
55916     }
55917   }
55918   jresult = (int)result;
55919   return jresult;
55920 }
55921
55922
55923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
55924   int jresult ;
55925   int result;
55926
55927   {
55928     try {
55929       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
55930     } catch (std::out_of_range& e) {
55931       {
55932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55933       };
55934     } catch (std::exception& e) {
55935       {
55936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55937       };
55938     } catch (...) {
55939       {
55940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55941       };
55942     }
55943   }
55944   jresult = (int)result;
55945   return jresult;
55946 }
55947
55948
55949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
55950   int jresult ;
55951   int result;
55952
55953   {
55954     try {
55955       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
55956     } catch (std::out_of_range& e) {
55957       {
55958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55959       };
55960     } catch (std::exception& e) {
55961       {
55962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55963       };
55964     } catch (...) {
55965       {
55966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55967       };
55968     }
55969   }
55970   jresult = (int)result;
55971   return jresult;
55972 }
55973
55974
55975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
55976   int jresult ;
55977   int result;
55978
55979   {
55980     try {
55981       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
55982     } catch (std::out_of_range& e) {
55983       {
55984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55985       };
55986     } catch (std::exception& e) {
55987       {
55988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55989       };
55990     } catch (...) {
55991       {
55992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55993       };
55994     }
55995   }
55996   jresult = (int)result;
55997   return jresult;
55998 }
55999
56000
56001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56002   int jresult ;
56003   int result;
56004
56005   {
56006     try {
56007       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56008     } catch (std::out_of_range& e) {
56009       {
56010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56011       };
56012     } catch (std::exception& e) {
56013       {
56014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56015       };
56016     } catch (...) {
56017       {
56018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56019       };
56020     }
56021   }
56022   jresult = (int)result;
56023   return jresult;
56024 }
56025
56026
56027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56028   int jresult ;
56029   int result;
56030
56031   {
56032     try {
56033       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56034     } catch (std::out_of_range& e) {
56035       {
56036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56037       };
56038     } catch (std::exception& e) {
56039       {
56040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56041       };
56042     } catch (...) {
56043       {
56044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56045       };
56046     }
56047   }
56048   jresult = (int)result;
56049   return jresult;
56050 }
56051
56052
56053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56054   int jresult ;
56055   int result;
56056
56057   {
56058     try {
56059       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56060     } catch (std::out_of_range& e) {
56061       {
56062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56063       };
56064     } catch (std::exception& e) {
56065       {
56066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56067       };
56068     } catch (...) {
56069       {
56070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56071       };
56072     }
56073   }
56074   jresult = (int)result;
56075   return jresult;
56076 }
56077
56078
56079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56080   int jresult ;
56081   int result;
56082
56083   {
56084     try {
56085       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56086     } catch (std::out_of_range& e) {
56087       {
56088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56089       };
56090     } catch (std::exception& e) {
56091       {
56092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56093       };
56094     } catch (...) {
56095       {
56096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56097       };
56098     }
56099   }
56100   jresult = (int)result;
56101   return jresult;
56102 }
56103
56104
56105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56106   int jresult ;
56107   int result;
56108
56109   {
56110     try {
56111       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56112     } catch (std::out_of_range& e) {
56113       {
56114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56115       };
56116     } catch (std::exception& e) {
56117       {
56118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56119       };
56120     } catch (...) {
56121       {
56122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56123       };
56124     }
56125   }
56126   jresult = (int)result;
56127   return jresult;
56128 }
56129
56130
56131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56132   int jresult ;
56133   int result;
56134
56135   {
56136     try {
56137       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56138     } catch (std::out_of_range& e) {
56139       {
56140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56141       };
56142     } catch (std::exception& e) {
56143       {
56144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56145       };
56146     } catch (...) {
56147       {
56148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56149       };
56150     }
56151   }
56152   jresult = (int)result;
56153   return jresult;
56154 }
56155
56156
56157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56158   int jresult ;
56159   int result;
56160
56161   {
56162     try {
56163       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56164     } catch (std::out_of_range& e) {
56165       {
56166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56167       };
56168     } catch (std::exception& e) {
56169       {
56170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56171       };
56172     } catch (...) {
56173       {
56174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56175       };
56176     }
56177   }
56178   jresult = (int)result;
56179   return jresult;
56180 }
56181
56182
56183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56184   int jresult ;
56185   int result;
56186
56187   {
56188     try {
56189       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56190     } catch (std::out_of_range& e) {
56191       {
56192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56193       };
56194     } catch (std::exception& e) {
56195       {
56196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56197       };
56198     } catch (...) {
56199       {
56200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56201       };
56202     }
56203   }
56204   jresult = (int)result;
56205   return jresult;
56206 }
56207
56208
56209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56210   int jresult ;
56211   int result;
56212
56213   {
56214     try {
56215       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56216     } catch (std::out_of_range& e) {
56217       {
56218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56219       };
56220     } catch (std::exception& e) {
56221       {
56222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56223       };
56224     } catch (...) {
56225       {
56226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56227       };
56228     }
56229   }
56230   jresult = (int)result;
56231   return jresult;
56232 }
56233
56234
56235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56236   int jresult ;
56237   int result;
56238
56239   {
56240     try {
56241       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56242     } catch (std::out_of_range& e) {
56243       {
56244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56245       };
56246     } catch (std::exception& e) {
56247       {
56248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56249       };
56250     } catch (...) {
56251       {
56252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56253       };
56254     }
56255   }
56256   jresult = (int)result;
56257   return jresult;
56258 }
56259
56260
56261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56262   int jresult ;
56263   int result;
56264
56265   {
56266     try {
56267       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56268     } catch (std::out_of_range& e) {
56269       {
56270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56271       };
56272     } catch (std::exception& e) {
56273       {
56274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56275       };
56276     } catch (...) {
56277       {
56278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56279       };
56280     }
56281   }
56282   jresult = (int)result;
56283   return jresult;
56284 }
56285
56286
56287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56288   int jresult ;
56289   int result;
56290
56291   {
56292     try {
56293       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56294     } catch (std::out_of_range& e) {
56295       {
56296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56297       };
56298     } catch (std::exception& e) {
56299       {
56300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56301       };
56302     } catch (...) {
56303       {
56304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56305       };
56306     }
56307   }
56308   jresult = (int)result;
56309   return jresult;
56310 }
56311
56312
56313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56314   int jresult ;
56315   int result;
56316
56317   {
56318     try {
56319       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56320     } catch (std::out_of_range& e) {
56321       {
56322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56323       };
56324     } catch (std::exception& e) {
56325       {
56326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56327       };
56328     } catch (...) {
56329       {
56330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56331       };
56332     }
56333   }
56334   jresult = (int)result;
56335   return jresult;
56336 }
56337
56338
56339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56340   int jresult ;
56341   int result;
56342
56343   {
56344     try {
56345       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56346     } catch (std::out_of_range& e) {
56347       {
56348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56349       };
56350     } catch (std::exception& e) {
56351       {
56352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56353       };
56354     } catch (...) {
56355       {
56356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56357       };
56358     }
56359   }
56360   jresult = (int)result;
56361   return jresult;
56362 }
56363
56364
56365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56366   int jresult ;
56367   int result;
56368
56369   {
56370     try {
56371       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56372     } catch (std::out_of_range& e) {
56373       {
56374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56375       };
56376     } catch (std::exception& e) {
56377       {
56378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56379       };
56380     } catch (...) {
56381       {
56382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56383       };
56384     }
56385   }
56386   jresult = (int)result;
56387   return jresult;
56388 }
56389
56390
56391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56392   int jresult ;
56393   int result;
56394
56395   {
56396     try {
56397       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56398     } catch (std::out_of_range& e) {
56399       {
56400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56401       };
56402     } catch (std::exception& e) {
56403       {
56404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56405       };
56406     } catch (...) {
56407       {
56408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56409       };
56410     }
56411   }
56412   jresult = (int)result;
56413   return jresult;
56414 }
56415
56416
56417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56418   int jresult ;
56419   int result;
56420
56421   {
56422     try {
56423       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56424     } catch (std::out_of_range& e) {
56425       {
56426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56427       };
56428     } catch (std::exception& e) {
56429       {
56430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56431       };
56432     } catch (...) {
56433       {
56434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56435       };
56436     }
56437   }
56438   jresult = (int)result;
56439   return jresult;
56440 }
56441
56442
56443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56444   int jresult ;
56445   int result;
56446
56447   {
56448     try {
56449       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56450     } catch (std::out_of_range& e) {
56451       {
56452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56453       };
56454     } catch (std::exception& e) {
56455       {
56456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (...) {
56459       {
56460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56461       };
56462     }
56463   }
56464   jresult = (int)result;
56465   return jresult;
56466 }
56467
56468
56469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56470   int jresult ;
56471   int result;
56472
56473   {
56474     try {
56475       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56476     } catch (std::out_of_range& e) {
56477       {
56478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56479       };
56480     } catch (std::exception& e) {
56481       {
56482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56483       };
56484     } catch (...) {
56485       {
56486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56487       };
56488     }
56489   }
56490   jresult = (int)result;
56491   return jresult;
56492 }
56493
56494
56495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56496   int jresult ;
56497   int result;
56498
56499   {
56500     try {
56501       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56502     } catch (std::out_of_range& e) {
56503       {
56504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56505       };
56506     } catch (std::exception& e) {
56507       {
56508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56509       };
56510     } catch (...) {
56511       {
56512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56513       };
56514     }
56515   }
56516   jresult = (int)result;
56517   return jresult;
56518 }
56519
56520
56521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56522   int jresult ;
56523   int result;
56524
56525   {
56526     try {
56527       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56528     } catch (std::out_of_range& e) {
56529       {
56530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56531       };
56532     } catch (std::exception& e) {
56533       {
56534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56535       };
56536     } catch (...) {
56537       {
56538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56539       };
56540     }
56541   }
56542   jresult = (int)result;
56543   return jresult;
56544 }
56545
56546
56547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56548   int jresult ;
56549   int result;
56550
56551   {
56552     try {
56553       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56554     } catch (std::out_of_range& e) {
56555       {
56556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56557       };
56558     } catch (std::exception& e) {
56559       {
56560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56561       };
56562     } catch (...) {
56563       {
56564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56565       };
56566     }
56567   }
56568   jresult = (int)result;
56569   return jresult;
56570 }
56571
56572
56573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
56574   int jresult ;
56575   int result;
56576
56577   {
56578     try {
56579       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
56580     } catch (std::out_of_range& e) {
56581       {
56582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56583       };
56584     } catch (std::exception& e) {
56585       {
56586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56587       };
56588     } catch (...) {
56589       {
56590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56591       };
56592     }
56593   }
56594   jresult = (int)result;
56595   return jresult;
56596 }
56597
56598
56599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
56600   int jresult ;
56601   int result;
56602
56603   {
56604     try {
56605       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
56606     } catch (std::out_of_range& e) {
56607       {
56608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56609       };
56610     } catch (std::exception& e) {
56611       {
56612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56613       };
56614     } catch (...) {
56615       {
56616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56617       };
56618     }
56619   }
56620   jresult = (int)result;
56621   return jresult;
56622 }
56623
56624
56625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
56626   int jresult ;
56627   int result;
56628
56629   {
56630     try {
56631       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
56632     } catch (std::out_of_range& e) {
56633       {
56634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56635       };
56636     } catch (std::exception& e) {
56637       {
56638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56639       };
56640     } catch (...) {
56641       {
56642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56643       };
56644     }
56645   }
56646   jresult = (int)result;
56647   return jresult;
56648 }
56649
56650
56651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
56652   int jresult ;
56653   int result;
56654
56655   {
56656     try {
56657       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
56658     } catch (std::out_of_range& e) {
56659       {
56660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56661       };
56662     } catch (std::exception& e) {
56663       {
56664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56665       };
56666     } catch (...) {
56667       {
56668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56669       };
56670     }
56671   }
56672   jresult = (int)result;
56673   return jresult;
56674 }
56675
56676
56677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
56678   int jresult ;
56679   int result;
56680
56681   {
56682     try {
56683       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
56684     } catch (std::out_of_range& e) {
56685       {
56686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56687       };
56688     } catch (std::exception& e) {
56689       {
56690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56691       };
56692     } catch (...) {
56693       {
56694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56695       };
56696     }
56697   }
56698   jresult = (int)result;
56699   return jresult;
56700 }
56701
56702
56703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
56704   int jresult ;
56705   int result;
56706
56707   {
56708     try {
56709       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
56710     } catch (std::out_of_range& e) {
56711       {
56712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56713       };
56714     } catch (std::exception& e) {
56715       {
56716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56717       };
56718     } catch (...) {
56719       {
56720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56721       };
56722     }
56723   }
56724   jresult = (int)result;
56725   return jresult;
56726 }
56727
56728
56729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
56730   int jresult ;
56731   int result;
56732
56733   {
56734     try {
56735       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
56736     } catch (std::out_of_range& e) {
56737       {
56738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56739       };
56740     } catch (std::exception& e) {
56741       {
56742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56743       };
56744     } catch (...) {
56745       {
56746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56747       };
56748     }
56749   }
56750   jresult = (int)result;
56751   return jresult;
56752 }
56753
56754
56755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
56756   int jresult ;
56757   int result;
56758
56759   {
56760     try {
56761       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
56762     } catch (std::out_of_range& e) {
56763       {
56764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56765       };
56766     } catch (std::exception& e) {
56767       {
56768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56769       };
56770     } catch (...) {
56771       {
56772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56773       };
56774     }
56775   }
56776   jresult = (int)result;
56777   return jresult;
56778 }
56779
56780
56781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
56782   int jresult ;
56783   int result;
56784
56785   {
56786     try {
56787       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
56788     } catch (std::out_of_range& e) {
56789       {
56790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56791       };
56792     } catch (std::exception& e) {
56793       {
56794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56795       };
56796     } catch (...) {
56797       {
56798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56799       };
56800     }
56801   }
56802   jresult = (int)result;
56803   return jresult;
56804 }
56805
56806
56807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
56808   void * jresult ;
56809   Dali::Toolkit::Builder *result = 0 ;
56810
56811   {
56812     try {
56813       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
56814     } catch (std::out_of_range& e) {
56815       {
56816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56817       };
56818     } catch (std::exception& e) {
56819       {
56820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56821       };
56822     } catch (...) {
56823       {
56824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56825       };
56826     }
56827   }
56828   jresult = (void *)result;
56829   return jresult;
56830 }
56831
56832
56833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
56834   void * jresult ;
56835   Dali::Toolkit::Builder result;
56836
56837   {
56838     try {
56839       result = Dali::Toolkit::Builder::New();
56840     } catch (std::out_of_range& e) {
56841       {
56842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56843       };
56844     } catch (std::exception& e) {
56845       {
56846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56847       };
56848     } catch (...) {
56849       {
56850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56851       };
56852     }
56853   }
56854   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
56855   return jresult;
56856 }
56857
56858
56859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
56860   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56861
56862   arg1 = (Dali::Toolkit::Builder *)jarg1;
56863   {
56864     try {
56865       delete arg1;
56866     } catch (std::out_of_range& e) {
56867       {
56868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56869       };
56870     } catch (std::exception& e) {
56871       {
56872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56873       };
56874     } catch (...) {
56875       {
56876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56877       };
56878     }
56879   }
56880 }
56881
56882
56883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
56884   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56885   std::string *arg2 = 0 ;
56886   Dali::Toolkit::Builder::UIFormat arg3 ;
56887
56888   arg1 = (Dali::Toolkit::Builder *)jarg1;
56889   if (!jarg2) {
56890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56891     return ;
56892   }
56893   std::string arg2_str(jarg2);
56894   arg2 = &arg2_str;
56895   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
56896   {
56897     try {
56898       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
56899     } catch (std::out_of_range& e) {
56900       {
56901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56902       };
56903     } catch (std::exception& e) {
56904       {
56905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56906       };
56907     } catch (...) {
56908       {
56909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56910       };
56911     }
56912   }
56913
56914   //argout typemap for const std::string&
56915
56916 }
56917
56918
56919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
56920   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56921   std::string *arg2 = 0 ;
56922
56923   arg1 = (Dali::Toolkit::Builder *)jarg1;
56924   if (!jarg2) {
56925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56926     return ;
56927   }
56928   std::string arg2_str(jarg2);
56929   arg2 = &arg2_str;
56930   {
56931     try {
56932       (arg1)->LoadFromString((std::string const &)*arg2);
56933     } catch (std::out_of_range& e) {
56934       {
56935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56936       };
56937     } catch (std::exception& e) {
56938       {
56939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56940       };
56941     } catch (...) {
56942       {
56943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56944       };
56945     }
56946   }
56947
56948   //argout typemap for const std::string&
56949
56950 }
56951
56952
56953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
56954   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56955   Dali::Property::Map *arg2 = 0 ;
56956
56957   arg1 = (Dali::Toolkit::Builder *)jarg1;
56958   arg2 = (Dali::Property::Map *)jarg2;
56959   if (!arg2) {
56960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
56961     return ;
56962   }
56963   {
56964     try {
56965       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
56966     } catch (std::out_of_range& e) {
56967       {
56968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56969       };
56970     } catch (std::exception& e) {
56971       {
56972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56973       };
56974     } catch (...) {
56975       {
56976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56977       };
56978     }
56979   }
56980 }
56981
56982
56983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
56984   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56985   std::string *arg2 = 0 ;
56986   Dali::Property::Value *arg3 = 0 ;
56987
56988   arg1 = (Dali::Toolkit::Builder *)jarg1;
56989   if (!jarg2) {
56990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56991     return ;
56992   }
56993   std::string arg2_str(jarg2);
56994   arg2 = &arg2_str;
56995   arg3 = (Dali::Property::Value *)jarg3;
56996   if (!arg3) {
56997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
56998     return ;
56999   }
57000   {
57001     try {
57002       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57003     } catch (std::out_of_range& e) {
57004       {
57005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57006       };
57007     } catch (std::exception& e) {
57008       {
57009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57010       };
57011     } catch (...) {
57012       {
57013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57014       };
57015     }
57016   }
57017
57018   //argout typemap for const std::string&
57019
57020 }
57021
57022
57023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57024   void * jresult ;
57025   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57026   Dali::Property::Map *result = 0 ;
57027
57028   arg1 = (Dali::Toolkit::Builder *)jarg1;
57029   {
57030     try {
57031       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57032     } catch (std::out_of_range& e) {
57033       {
57034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57035       };
57036     } catch (std::exception& e) {
57037       {
57038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57039       };
57040     } catch (...) {
57041       {
57042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57043       };
57044     }
57045   }
57046   jresult = (void *)result;
57047   return jresult;
57048 }
57049
57050
57051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57052   void * jresult ;
57053   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57054   std::string *arg2 = 0 ;
57055   Dali::Property::Value *result = 0 ;
57056
57057   arg1 = (Dali::Toolkit::Builder *)jarg1;
57058   if (!jarg2) {
57059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57060     return 0;
57061   }
57062   std::string arg2_str(jarg2);
57063   arg2 = &arg2_str;
57064   {
57065     try {
57066       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57067     } catch (std::out_of_range& e) {
57068       {
57069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57070       };
57071     } catch (std::exception& e) {
57072       {
57073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57074       };
57075     } catch (...) {
57076       {
57077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57078       };
57079     }
57080   }
57081   jresult = (void *)result;
57082
57083   //argout typemap for const std::string&
57084
57085   return jresult;
57086 }
57087
57088
57089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57090   void * jresult ;
57091   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57092   std::string *arg2 = 0 ;
57093   Dali::Animation result;
57094
57095   arg1 = (Dali::Toolkit::Builder *)jarg1;
57096   if (!jarg2) {
57097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57098     return 0;
57099   }
57100   std::string arg2_str(jarg2);
57101   arg2 = &arg2_str;
57102   {
57103     try {
57104       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57105     } catch (std::out_of_range& e) {
57106       {
57107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57108       };
57109     } catch (std::exception& e) {
57110       {
57111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57112       };
57113     } catch (...) {
57114       {
57115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57116       };
57117     }
57118   }
57119   jresult = new Dali::Animation((const Dali::Animation &)result);
57120
57121   //argout typemap for const std::string&
57122
57123   return jresult;
57124 }
57125
57126
57127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57128   void * jresult ;
57129   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57130   std::string *arg2 = 0 ;
57131   Dali::Property::Map *arg3 = 0 ;
57132   Dali::Animation result;
57133
57134   arg1 = (Dali::Toolkit::Builder *)jarg1;
57135   if (!jarg2) {
57136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57137     return 0;
57138   }
57139   std::string arg2_str(jarg2);
57140   arg2 = &arg2_str;
57141   arg3 = (Dali::Property::Map *)jarg3;
57142   if (!arg3) {
57143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57144     return 0;
57145   }
57146   {
57147     try {
57148       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57149     } catch (std::out_of_range& e) {
57150       {
57151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57152       };
57153     } catch (std::exception& e) {
57154       {
57155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57156       };
57157     } catch (...) {
57158       {
57159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57160       };
57161     }
57162   }
57163   jresult = new Dali::Animation((const Dali::Animation &)result);
57164
57165   //argout typemap for const std::string&
57166
57167   return jresult;
57168 }
57169
57170
57171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57172   void * jresult ;
57173   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57174   std::string *arg2 = 0 ;
57175   Dali::Actor arg3 ;
57176   Dali::Actor *argp3 ;
57177   Dali::Animation result;
57178
57179   arg1 = (Dali::Toolkit::Builder *)jarg1;
57180   if (!jarg2) {
57181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57182     return 0;
57183   }
57184   std::string arg2_str(jarg2);
57185   arg2 = &arg2_str;
57186   argp3 = (Dali::Actor *)jarg3;
57187   if (!argp3) {
57188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57189     return 0;
57190   }
57191   arg3 = *argp3;
57192   {
57193     try {
57194       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57195     } catch (std::out_of_range& e) {
57196       {
57197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57198       };
57199     } catch (std::exception& e) {
57200       {
57201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57202       };
57203     } catch (...) {
57204       {
57205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57206       };
57207     }
57208   }
57209   jresult = new Dali::Animation((const Dali::Animation &)result);
57210
57211   //argout typemap for const std::string&
57212
57213   return jresult;
57214 }
57215
57216
57217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57218   void * jresult ;
57219   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57220   std::string *arg2 = 0 ;
57221   Dali::Property::Map *arg3 = 0 ;
57222   Dali::Actor arg4 ;
57223   Dali::Actor *argp4 ;
57224   Dali::Animation result;
57225
57226   arg1 = (Dali::Toolkit::Builder *)jarg1;
57227   if (!jarg2) {
57228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57229     return 0;
57230   }
57231   std::string arg2_str(jarg2);
57232   arg2 = &arg2_str;
57233   arg3 = (Dali::Property::Map *)jarg3;
57234   if (!arg3) {
57235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57236     return 0;
57237   }
57238   argp4 = (Dali::Actor *)jarg4;
57239   if (!argp4) {
57240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57241     return 0;
57242   }
57243   arg4 = *argp4;
57244   {
57245     try {
57246       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57247     } catch (std::out_of_range& e) {
57248       {
57249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57250       };
57251     } catch (std::exception& e) {
57252       {
57253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57254       };
57255     } catch (...) {
57256       {
57257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57258       };
57259     }
57260   }
57261   jresult = new Dali::Animation((const Dali::Animation &)result);
57262
57263   //argout typemap for const std::string&
57264
57265   return jresult;
57266 }
57267
57268
57269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57270   void * jresult ;
57271   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57272   std::string *arg2 = 0 ;
57273   Dali::BaseHandle result;
57274
57275   arg1 = (Dali::Toolkit::Builder *)jarg1;
57276   if (!jarg2) {
57277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57278     return 0;
57279   }
57280   std::string arg2_str(jarg2);
57281   arg2 = &arg2_str;
57282   {
57283     try {
57284       result = (arg1)->Create((std::string const &)*arg2);
57285     } catch (std::out_of_range& e) {
57286       {
57287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57288       };
57289     } catch (std::exception& e) {
57290       {
57291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57292       };
57293     } catch (...) {
57294       {
57295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57296       };
57297     }
57298   }
57299   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57300
57301   //argout typemap for const std::string&
57302
57303   return jresult;
57304 }
57305
57306
57307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57308   void * jresult ;
57309   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57310   std::string *arg2 = 0 ;
57311   Dali::Property::Map *arg3 = 0 ;
57312   Dali::BaseHandle result;
57313
57314   arg1 = (Dali::Toolkit::Builder *)jarg1;
57315   if (!jarg2) {
57316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57317     return 0;
57318   }
57319   std::string arg2_str(jarg2);
57320   arg2 = &arg2_str;
57321   arg3 = (Dali::Property::Map *)jarg3;
57322   if (!arg3) {
57323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57324     return 0;
57325   }
57326   {
57327     try {
57328       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57329     } catch (std::out_of_range& e) {
57330       {
57331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57332       };
57333     } catch (std::exception& e) {
57334       {
57335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57336       };
57337     } catch (...) {
57338       {
57339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57340       };
57341     }
57342   }
57343   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57344
57345   //argout typemap for const std::string&
57346
57347   return jresult;
57348 }
57349
57350
57351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57352   void * jresult ;
57353   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57354   std::string *arg2 = 0 ;
57355   Dali::BaseHandle result;
57356
57357   arg1 = (Dali::Toolkit::Builder *)jarg1;
57358   if (!jarg2) {
57359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57360     return 0;
57361   }
57362   std::string arg2_str(jarg2);
57363   arg2 = &arg2_str;
57364   {
57365     try {
57366       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57367     } catch (std::out_of_range& e) {
57368       {
57369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57370       };
57371     } catch (std::exception& e) {
57372       {
57373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57374       };
57375     } catch (...) {
57376       {
57377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57378       };
57379     }
57380   }
57381   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57382
57383   //argout typemap for const std::string&
57384
57385   return jresult;
57386 }
57387
57388
57389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57390   unsigned int jresult ;
57391   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57392   std::string *arg2 = 0 ;
57393   Dali::Handle *arg3 = 0 ;
57394   bool result;
57395
57396   arg1 = (Dali::Toolkit::Builder *)jarg1;
57397   if (!jarg2) {
57398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57399     return 0;
57400   }
57401   std::string arg2_str(jarg2);
57402   arg2 = &arg2_str;
57403   arg3 = (Dali::Handle *)jarg3;
57404   if (!arg3) {
57405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57406     return 0;
57407   }
57408   {
57409     try {
57410       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57411     } catch (std::out_of_range& e) {
57412       {
57413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57414       };
57415     } catch (std::exception& e) {
57416       {
57417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57418       };
57419     } catch (...) {
57420       {
57421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57422       };
57423     }
57424   }
57425   jresult = result;
57426
57427   //argout typemap for const std::string&
57428
57429   return jresult;
57430 }
57431
57432
57433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57434   unsigned int jresult ;
57435   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57436   Dali::Handle *arg2 = 0 ;
57437   std::string *arg3 = 0 ;
57438   bool result;
57439
57440   arg1 = (Dali::Toolkit::Builder *)jarg1;
57441   arg2 = (Dali::Handle *)jarg2;
57442   if (!arg2) {
57443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57444     return 0;
57445   }
57446   if (!jarg3) {
57447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57448     return 0;
57449   }
57450   std::string arg3_str(jarg3);
57451   arg3 = &arg3_str;
57452   {
57453     try {
57454       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57455     } catch (std::out_of_range& e) {
57456       {
57457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57458       };
57459     } catch (std::exception& e) {
57460       {
57461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57462       };
57463     } catch (...) {
57464       {
57465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57466       };
57467     }
57468   }
57469   jresult = result;
57470
57471   //argout typemap for const std::string&
57472
57473   return jresult;
57474 }
57475
57476
57477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57478   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57479   Dali::Actor arg2 ;
57480   Dali::Actor *argp2 ;
57481
57482   arg1 = (Dali::Toolkit::Builder *)jarg1;
57483   argp2 = (Dali::Actor *)jarg2;
57484   if (!argp2) {
57485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57486     return ;
57487   }
57488   arg2 = *argp2;
57489   {
57490     try {
57491       (arg1)->AddActors(arg2);
57492     } catch (std::out_of_range& e) {
57493       {
57494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57495       };
57496     } catch (std::exception& e) {
57497       {
57498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57499       };
57500     } catch (...) {
57501       {
57502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57503       };
57504     }
57505   }
57506 }
57507
57508
57509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57510   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57511   std::string *arg2 = 0 ;
57512   Dali::Actor arg3 ;
57513   Dali::Actor *argp3 ;
57514
57515   arg1 = (Dali::Toolkit::Builder *)jarg1;
57516   if (!jarg2) {
57517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57518     return ;
57519   }
57520   std::string arg2_str(jarg2);
57521   arg2 = &arg2_str;
57522   argp3 = (Dali::Actor *)jarg3;
57523   if (!argp3) {
57524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57525     return ;
57526   }
57527   arg3 = *argp3;
57528   {
57529     try {
57530       (arg1)->AddActors((std::string const &)*arg2,arg3);
57531     } catch (std::out_of_range& e) {
57532       {
57533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57534       };
57535     } catch (std::exception& e) {
57536       {
57537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57538       };
57539     } catch (...) {
57540       {
57541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57542       };
57543     }
57544   }
57545
57546   //argout typemap for const std::string&
57547
57548 }
57549
57550
57551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
57552   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57553   std::string *arg2 = 0 ;
57554
57555   arg1 = (Dali::Toolkit::Builder *)jarg1;
57556   if (!jarg2) {
57557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57558     return ;
57559   }
57560   std::string arg2_str(jarg2);
57561   arg2 = &arg2_str;
57562   {
57563     try {
57564       (arg1)->CreateRenderTask((std::string const &)*arg2);
57565     } catch (std::out_of_range& e) {
57566       {
57567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57568       };
57569     } catch (std::exception& e) {
57570       {
57571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57572       };
57573     } catch (...) {
57574       {
57575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57576       };
57577     }
57578   }
57579
57580   //argout typemap for const std::string&
57581
57582 }
57583
57584
57585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
57586   void * jresult ;
57587   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57588   std::string *arg2 = 0 ;
57589   Dali::FrameBufferImage result;
57590
57591   arg1 = (Dali::Toolkit::Builder *)jarg1;
57592   if (!jarg2) {
57593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57594     return 0;
57595   }
57596   std::string arg2_str(jarg2);
57597   arg2 = &arg2_str;
57598   {
57599     try {
57600       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
57601     } catch (std::out_of_range& e) {
57602       {
57603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57604       };
57605     } catch (std::exception& e) {
57606       {
57607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57608       };
57609     } catch (...) {
57610       {
57611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57612       };
57613     }
57614   }
57615   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
57616
57617   //argout typemap for const std::string&
57618
57619   return jresult;
57620 }
57621
57622
57623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
57624   void * jresult ;
57625   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57626   std::string *arg2 = 0 ;
57627   Dali::Path result;
57628
57629   arg1 = (Dali::Toolkit::Builder *)jarg1;
57630   if (!jarg2) {
57631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57632     return 0;
57633   }
57634   std::string arg2_str(jarg2);
57635   arg2 = &arg2_str;
57636   {
57637     try {
57638       result = (arg1)->GetPath((std::string const &)*arg2);
57639     } catch (std::out_of_range& e) {
57640       {
57641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57642       };
57643     } catch (std::exception& e) {
57644       {
57645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57646       };
57647     } catch (...) {
57648       {
57649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57650       };
57651     }
57652   }
57653   jresult = new Dali::Path((const Dali::Path &)result);
57654
57655   //argout typemap for const std::string&
57656
57657   return jresult;
57658 }
57659
57660
57661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
57662   void * jresult ;
57663   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57664   std::string *arg2 = 0 ;
57665   Dali::PathConstrainer result;
57666
57667   arg1 = (Dali::Toolkit::Builder *)jarg1;
57668   if (!jarg2) {
57669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57670     return 0;
57671   }
57672   std::string arg2_str(jarg2);
57673   arg2 = &arg2_str;
57674   {
57675     try {
57676       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
57677     } catch (std::out_of_range& e) {
57678       {
57679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57680       };
57681     } catch (std::exception& e) {
57682       {
57683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57684       };
57685     } catch (...) {
57686       {
57687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57688       };
57689     }
57690   }
57691   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
57692
57693   //argout typemap for const std::string&
57694
57695   return jresult;
57696 }
57697
57698
57699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
57700   void * jresult ;
57701   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57702   std::string *arg2 = 0 ;
57703   Dali::LinearConstrainer result;
57704
57705   arg1 = (Dali::Toolkit::Builder *)jarg1;
57706   if (!jarg2) {
57707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57708     return 0;
57709   }
57710   std::string arg2_str(jarg2);
57711   arg2 = &arg2_str;
57712   {
57713     try {
57714       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
57715     } catch (std::out_of_range& e) {
57716       {
57717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57718       };
57719     } catch (std::exception& e) {
57720       {
57721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57722       };
57723     } catch (...) {
57724       {
57725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57726       };
57727     }
57728   }
57729   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
57730
57731   //argout typemap for const std::string&
57732
57733   return jresult;
57734 }
57735
57736
57737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
57738   void * jresult ;
57739   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57740   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
57741
57742   arg1 = (Dali::Toolkit::Builder *)jarg1;
57743   {
57744     try {
57745       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
57746     } catch (std::out_of_range& e) {
57747       {
57748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57749       };
57750     } catch (std::exception& e) {
57751       {
57752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57753       };
57754     } catch (...) {
57755       {
57756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57757       };
57758     }
57759   }
57760   jresult = (void *)result;
57761   return jresult;
57762 }
57763
57764
57765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
57766   void * jresult ;
57767   Dali::Toolkit::TransitionData *result = 0 ;
57768
57769   {
57770     try {
57771       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
57772     } catch (std::out_of_range& e) {
57773       {
57774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57775       };
57776     } catch (std::exception& e) {
57777       {
57778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57779       };
57780     } catch (...) {
57781       {
57782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57783       };
57784     }
57785   }
57786   jresult = (void *)result;
57787   return jresult;
57788 }
57789
57790
57791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
57792   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
57793
57794   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
57795   {
57796     try {
57797       delete arg1;
57798     } catch (std::out_of_range& e) {
57799       {
57800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57801       };
57802     } catch (std::exception& e) {
57803       {
57804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57805       };
57806     } catch (...) {
57807       {
57808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57809       };
57810     }
57811   }
57812 }
57813
57814
57815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
57816   void * jresult ;
57817   Dali::Property::Map *arg1 = 0 ;
57818   Dali::Toolkit::TransitionData result;
57819
57820   arg1 = (Dali::Property::Map *)jarg1;
57821   if (!arg1) {
57822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57823     return 0;
57824   }
57825   {
57826     try {
57827       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
57828     } catch (std::out_of_range& e) {
57829       {
57830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57831       };
57832     } catch (std::exception& e) {
57833       {
57834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57835       };
57836     } catch (...) {
57837       {
57838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57839       };
57840     }
57841   }
57842   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
57843   return jresult;
57844 }
57845
57846
57847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
57848   void * jresult ;
57849   Dali::Property::Array *arg1 = 0 ;
57850   Dali::Toolkit::TransitionData result;
57851
57852   arg1 = (Dali::Property::Array *)jarg1;
57853   if (!arg1) {
57854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
57855     return 0;
57856   }
57857   {
57858     try {
57859       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
57860     } catch (std::out_of_range& e) {
57861       {
57862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57863       };
57864     } catch (std::exception& e) {
57865       {
57866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57867       };
57868     } catch (...) {
57869       {
57870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57871       };
57872     }
57873   }
57874   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
57875   return jresult;
57876 }
57877
57878
57879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
57880   void * jresult ;
57881   Dali::BaseHandle arg1 ;
57882   Dali::BaseHandle *argp1 ;
57883   Dali::Toolkit::TransitionData result;
57884
57885   argp1 = (Dali::BaseHandle *)jarg1;
57886   if (!argp1) {
57887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
57888     return 0;
57889   }
57890   arg1 = *argp1;
57891   {
57892     try {
57893       result = Dali::Toolkit::TransitionData::DownCast(arg1);
57894     } catch (std::out_of_range& e) {
57895       {
57896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57897       };
57898     } catch (std::exception& e) {
57899       {
57900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57901       };
57902     } catch (...) {
57903       {
57904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57905       };
57906     }
57907   }
57908   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
57909   return jresult;
57910 }
57911
57912
57913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
57914   void * jresult ;
57915   Dali::Toolkit::TransitionData *arg1 = 0 ;
57916   Dali::Toolkit::TransitionData *result = 0 ;
57917
57918   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
57919   if (!arg1) {
57920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
57921     return 0;
57922   }
57923   {
57924     try {
57925       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
57926     } catch (std::out_of_range& e) {
57927       {
57928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57929       };
57930     } catch (std::exception& e) {
57931       {
57932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57933       };
57934     } catch (...) {
57935       {
57936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57937       };
57938     }
57939   }
57940   jresult = (void *)result;
57941   return jresult;
57942 }
57943
57944
57945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
57946   void * jresult ;
57947   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
57948   Dali::Toolkit::TransitionData *arg2 = 0 ;
57949   Dali::Toolkit::TransitionData *result = 0 ;
57950
57951   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
57952   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
57953   if (!arg2) {
57954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
57955     return 0;
57956   }
57957   {
57958     try {
57959       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
57960     } catch (std::out_of_range& e) {
57961       {
57962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57963       };
57964     } catch (std::exception& e) {
57965       {
57966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57967       };
57968     } catch (...) {
57969       {
57970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57971       };
57972     }
57973   }
57974   jresult = (void *)result;
57975   return jresult;
57976 }
57977
57978
57979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
57980   unsigned long jresult ;
57981   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
57982   size_t result;
57983
57984   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
57985   {
57986     try {
57987       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
57988     } catch (std::out_of_range& e) {
57989       {
57990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57991       };
57992     } catch (std::exception& e) {
57993       {
57994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57995       };
57996     } catch (...) {
57997       {
57998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57999       };
58000     }
58001   }
58002   jresult = (unsigned long)result;
58003   return jresult;
58004 }
58005
58006
58007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58008   void * jresult ;
58009   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58010   size_t arg2 ;
58011   Dali::Property::Map result;
58012
58013   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58014   arg2 = (size_t)jarg2;
58015   {
58016     try {
58017       result = (arg1)->GetAnimatorAt(arg2);
58018     } catch (std::out_of_range& e) {
58019       {
58020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58021       };
58022     } catch (std::exception& e) {
58023       {
58024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58025       };
58026     } catch (...) {
58027       {
58028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58029       };
58030     }
58031   }
58032   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58033   return jresult;
58034 }
58035
58036
58037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58038   void * jresult ;
58039   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58040   Dali::Toolkit::TransitionData *result = 0 ;
58041
58042   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58043   {
58044     try {
58045       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58046     } catch (std::out_of_range& e) {
58047       {
58048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58049       };
58050     } catch (std::exception& e) {
58051       {
58052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58053       };
58054     } catch (...) {
58055       {
58056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58057       };
58058     }
58059   }
58060   jresult = (void *)result;
58061   return jresult;
58062 }
58063
58064
58065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58066   int jresult ;
58067   int result;
58068
58069   {
58070     try {
58071       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58072     } catch (std::out_of_range& e) {
58073       {
58074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58075       };
58076     } catch (std::exception& e) {
58077       {
58078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58079       };
58080     } catch (...) {
58081       {
58082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58083       };
58084     }
58085   }
58086   jresult = (int)result;
58087   return jresult;
58088 }
58089
58090
58091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58092   int jresult ;
58093   int result;
58094
58095   {
58096     try {
58097       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58098     } catch (std::out_of_range& e) {
58099       {
58100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58101       };
58102     } catch (std::exception& e) {
58103       {
58104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58105       };
58106     } catch (...) {
58107       {
58108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58109       };
58110     }
58111   }
58112   jresult = (int)result;
58113   return jresult;
58114 }
58115
58116
58117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58118   int jresult ;
58119   int result;
58120
58121   {
58122     try {
58123       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58124     } catch (std::out_of_range& e) {
58125       {
58126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58127       };
58128     } catch (std::exception& e) {
58129       {
58130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58131       };
58132     } catch (...) {
58133       {
58134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58135       };
58136     }
58137   }
58138   jresult = (int)result;
58139   return jresult;
58140 }
58141
58142
58143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58144   int jresult ;
58145   int result;
58146
58147   {
58148     try {
58149       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58150     } catch (std::out_of_range& e) {
58151       {
58152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58153       };
58154     } catch (std::exception& e) {
58155       {
58156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58157       };
58158     } catch (...) {
58159       {
58160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58161       };
58162     }
58163   }
58164   jresult = (int)result;
58165   return jresult;
58166 }
58167
58168
58169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58170   int jresult ;
58171   int result;
58172
58173   {
58174     try {
58175       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58176     } catch (std::out_of_range& e) {
58177       {
58178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58179       };
58180     } catch (std::exception& e) {
58181       {
58182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58183       };
58184     } catch (...) {
58185       {
58186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58187       };
58188     }
58189   }
58190   jresult = (int)result;
58191   return jresult;
58192 }
58193
58194
58195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58196   int jresult ;
58197   int result;
58198
58199   {
58200     try {
58201       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58202     } catch (std::out_of_range& e) {
58203       {
58204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58205       };
58206     } catch (std::exception& e) {
58207       {
58208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58209       };
58210     } catch (...) {
58211       {
58212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58213       };
58214     }
58215   }
58216   jresult = (int)result;
58217   return jresult;
58218 }
58219
58220
58221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58222   int jresult ;
58223   int result;
58224
58225   {
58226     try {
58227       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58228     } catch (std::out_of_range& e) {
58229       {
58230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58231       };
58232     } catch (std::exception& e) {
58233       {
58234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58235       };
58236     } catch (...) {
58237       {
58238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58239       };
58240     }
58241   }
58242   jresult = (int)result;
58243   return jresult;
58244 }
58245
58246
58247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58248   int jresult ;
58249   int result;
58250
58251   {
58252     try {
58253       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58254     } catch (std::out_of_range& e) {
58255       {
58256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58257       };
58258     } catch (std::exception& e) {
58259       {
58260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58261       };
58262     } catch (...) {
58263       {
58264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58265       };
58266     }
58267   }
58268   jresult = (int)result;
58269   return jresult;
58270 }
58271
58272
58273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58274   int jresult ;
58275   int result;
58276
58277   {
58278     try {
58279       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58280     } catch (std::out_of_range& e) {
58281       {
58282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58283       };
58284     } catch (std::exception& e) {
58285       {
58286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58287       };
58288     } catch (...) {
58289       {
58290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58291       };
58292     }
58293   }
58294   jresult = (int)result;
58295   return jresult;
58296 }
58297
58298
58299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58300   int jresult ;
58301   int result;
58302
58303   {
58304     try {
58305       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58306     } catch (std::out_of_range& e) {
58307       {
58308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58309       };
58310     } catch (std::exception& e) {
58311       {
58312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58313       };
58314     } catch (...) {
58315       {
58316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58317       };
58318     }
58319   }
58320   jresult = (int)result;
58321   return jresult;
58322 }
58323
58324
58325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58326   int jresult ;
58327   int result;
58328
58329   {
58330     try {
58331       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58332     } catch (std::out_of_range& e) {
58333       {
58334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58335       };
58336     } catch (std::exception& e) {
58337       {
58338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58339       };
58340     } catch (...) {
58341       {
58342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58343       };
58344     }
58345   }
58346   jresult = (int)result;
58347   return jresult;
58348 }
58349
58350
58351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58352   int jresult ;
58353   int result;
58354
58355   {
58356     try {
58357       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58358     } catch (std::out_of_range& e) {
58359       {
58360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58361       };
58362     } catch (std::exception& e) {
58363       {
58364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58365       };
58366     } catch (...) {
58367       {
58368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58369       };
58370     }
58371   }
58372   jresult = (int)result;
58373   return jresult;
58374 }
58375
58376
58377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58378   int jresult ;
58379   int result;
58380
58381   {
58382     try {
58383       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58384     } catch (std::out_of_range& e) {
58385       {
58386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58387       };
58388     } catch (std::exception& e) {
58389       {
58390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58391       };
58392     } catch (...) {
58393       {
58394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58395       };
58396     }
58397   }
58398   jresult = (int)result;
58399   return jresult;
58400 }
58401
58402
58403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58404   int jresult ;
58405   int result;
58406
58407   {
58408     try {
58409       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58410     } catch (std::out_of_range& e) {
58411       {
58412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58413       };
58414     } catch (std::exception& e) {
58415       {
58416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58417       };
58418     } catch (...) {
58419       {
58420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58421       };
58422     }
58423   }
58424   jresult = (int)result;
58425   return jresult;
58426 }
58427
58428
58429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58430   void * jresult ;
58431   Dali::Toolkit::Control result;
58432
58433   {
58434     try {
58435       result = Dali::Toolkit::Internal::Control::New();
58436     } catch (std::out_of_range& e) {
58437       {
58438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58439       };
58440     } catch (std::exception& e) {
58441       {
58442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58443       };
58444     } catch (...) {
58445       {
58446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58447       };
58448     }
58449   }
58450   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58451   return jresult;
58452 }
58453
58454
58455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
58456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58457   std::string *arg2 = 0 ;
58458
58459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58460   if (!jarg2) {
58461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58462     return ;
58463   }
58464   std::string arg2_str(jarg2);
58465   arg2 = &arg2_str;
58466   {
58467     try {
58468       (arg1)->SetStyleName((std::string const &)*arg2);
58469     } catch (std::out_of_range& e) {
58470       {
58471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58472       };
58473     } catch (std::exception& e) {
58474       {
58475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58476       };
58477     } catch (...) {
58478       {
58479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58480       };
58481     }
58482   }
58483
58484   //argout typemap for const std::string&
58485
58486 }
58487
58488
58489 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
58490   char * jresult ;
58491   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58492   std::string *result = 0 ;
58493
58494   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58495   {
58496     try {
58497       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
58498     } catch (std::out_of_range& e) {
58499       {
58500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58501       };
58502     } catch (std::exception& e) {
58503       {
58504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58505       };
58506     } catch (...) {
58507       {
58508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58509       };
58510     }
58511   }
58512   jresult = SWIG_csharp_string_callback(result->c_str());
58513   return jresult;
58514 }
58515
58516
58517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
58518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58519   Dali::Vector4 *arg2 = 0 ;
58520
58521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58522   arg2 = (Dali::Vector4 *)jarg2;
58523   if (!arg2) {
58524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58525     return ;
58526   }
58527   {
58528     try {
58529       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58530     } catch (std::out_of_range& e) {
58531       {
58532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58533       };
58534     } catch (std::exception& e) {
58535       {
58536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58537       };
58538     } catch (...) {
58539       {
58540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58541       };
58542     }
58543   }
58544 }
58545
58546
58547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
58548   void * jresult ;
58549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58550   Dali::Vector4 result;
58551
58552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58553   {
58554     try {
58555       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
58556     } catch (std::out_of_range& e) {
58557       {
58558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58559       };
58560     } catch (std::exception& e) {
58561       {
58562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58563       };
58564     } catch (...) {
58565       {
58566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58567       };
58568     }
58569   }
58570   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58571   return jresult;
58572 }
58573
58574
58575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
58576   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58577   Dali::Image arg2 ;
58578   Dali::Image *argp2 ;
58579
58580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58581   argp2 = (Dali::Image *)jarg2;
58582   if (!argp2) {
58583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58584     return ;
58585   }
58586   arg2 = *argp2;
58587   {
58588     try {
58589       (arg1)->SetBackgroundImage(arg2);
58590     } catch (std::out_of_range& e) {
58591       {
58592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58593       };
58594     } catch (std::exception& e) {
58595       {
58596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58597       };
58598     } catch (...) {
58599       {
58600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58601       };
58602     }
58603   }
58604 }
58605
58606
58607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
58608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58609   Dali::Property::Map *arg2 = 0 ;
58610
58611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58612   arg2 = (Dali::Property::Map *)jarg2;
58613   if (!arg2) {
58614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58615     return ;
58616   }
58617   {
58618     try {
58619       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
58620     } catch (std::out_of_range& e) {
58621       {
58622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58623       };
58624     } catch (std::exception& e) {
58625       {
58626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58627       };
58628     } catch (...) {
58629       {
58630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58631       };
58632     }
58633   }
58634 }
58635
58636
58637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
58638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58639
58640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58641   {
58642     try {
58643       (arg1)->ClearBackground();
58644     } catch (std::out_of_range& e) {
58645       {
58646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58647       };
58648     } catch (std::exception& e) {
58649       {
58650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58651       };
58652     } catch (...) {
58653       {
58654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58655       };
58656     }
58657   }
58658 }
58659
58660
58661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
58662   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58663   Dali::Gesture::Type arg2 ;
58664
58665   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58666   arg2 = (Dali::Gesture::Type)jarg2;
58667   {
58668     try {
58669       (arg1)->EnableGestureDetection(arg2);
58670     } catch (std::out_of_range& e) {
58671       {
58672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58673       };
58674     } catch (std::exception& e) {
58675       {
58676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58677       };
58678     } catch (...) {
58679       {
58680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58681       };
58682     }
58683   }
58684 }
58685
58686
58687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
58688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58689   Dali::Gesture::Type arg2 ;
58690
58691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58692   arg2 = (Dali::Gesture::Type)jarg2;
58693   {
58694     try {
58695       (arg1)->DisableGestureDetection(arg2);
58696     } catch (std::out_of_range& e) {
58697       {
58698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58699       };
58700     } catch (std::exception& e) {
58701       {
58702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58703       };
58704     } catch (...) {
58705       {
58706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58707       };
58708     }
58709   }
58710 }
58711
58712
58713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
58714   void * jresult ;
58715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58716   Dali::PinchGestureDetector result;
58717
58718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58719   {
58720     try {
58721       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
58722     } catch (std::out_of_range& e) {
58723       {
58724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58725       };
58726     } catch (std::exception& e) {
58727       {
58728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58729       };
58730     } catch (...) {
58731       {
58732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58733       };
58734     }
58735   }
58736   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58737   return jresult;
58738 }
58739
58740
58741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
58742   void * jresult ;
58743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58744   Dali::PanGestureDetector result;
58745
58746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58747   {
58748     try {
58749       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
58750     } catch (std::out_of_range& e) {
58751       {
58752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58753       };
58754     } catch (std::exception& e) {
58755       {
58756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58757       };
58758     } catch (...) {
58759       {
58760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58761       };
58762     }
58763   }
58764   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
58765   return jresult;
58766 }
58767
58768
58769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
58770   void * jresult ;
58771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58772   Dali::TapGestureDetector result;
58773
58774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58775   {
58776     try {
58777       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
58778     } catch (std::out_of_range& e) {
58779       {
58780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58781       };
58782     } catch (std::exception& e) {
58783       {
58784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58785       };
58786     } catch (...) {
58787       {
58788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58789       };
58790     }
58791   }
58792   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
58793   return jresult;
58794 }
58795
58796
58797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
58798   void * jresult ;
58799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58800   Dali::LongPressGestureDetector result;
58801
58802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58803   {
58804     try {
58805       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
58806     } catch (std::out_of_range& e) {
58807       {
58808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58809       };
58810     } catch (std::exception& e) {
58811       {
58812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58813       };
58814     } catch (...) {
58815       {
58816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58817       };
58818     }
58819   }
58820   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
58821   return jresult;
58822 }
58823
58824
58825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
58826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58827   bool arg2 ;
58828
58829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58830   arg2 = jarg2 ? true : false;
58831   {
58832     try {
58833       (arg1)->SetKeyboardNavigationSupport(arg2);
58834     } catch (std::out_of_range& e) {
58835       {
58836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58837       };
58838     } catch (std::exception& e) {
58839       {
58840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58841       };
58842     } catch (...) {
58843       {
58844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58845       };
58846     }
58847   }
58848 }
58849
58850
58851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
58852   unsigned int jresult ;
58853   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58854   bool result;
58855
58856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58857   {
58858     try {
58859       result = (bool)(arg1)->IsKeyboardNavigationSupported();
58860     } catch (std::out_of_range& e) {
58861       {
58862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58863       };
58864     } catch (std::exception& e) {
58865       {
58866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58867       };
58868     } catch (...) {
58869       {
58870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58871       };
58872     }
58873   }
58874   jresult = result;
58875   return jresult;
58876 }
58877
58878
58879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
58880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58881
58882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58883   {
58884     try {
58885       (arg1)->SetKeyInputFocus();
58886     } catch (std::out_of_range& e) {
58887       {
58888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58889       };
58890     } catch (std::exception& e) {
58891       {
58892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58893       };
58894     } catch (...) {
58895       {
58896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58897       };
58898     }
58899   }
58900 }
58901
58902
58903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
58904   unsigned int jresult ;
58905   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58906   bool result;
58907
58908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58909   {
58910     try {
58911       result = (bool)(arg1)->HasKeyInputFocus();
58912     } catch (std::out_of_range& e) {
58913       {
58914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58915       };
58916     } catch (std::exception& e) {
58917       {
58918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58919       };
58920     } catch (...) {
58921       {
58922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58923       };
58924     }
58925   }
58926   jresult = result;
58927   return jresult;
58928 }
58929
58930
58931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
58932   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58933
58934   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58935   {
58936     try {
58937       (arg1)->ClearKeyInputFocus();
58938     } catch (std::out_of_range& e) {
58939       {
58940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58941       };
58942     } catch (std::exception& e) {
58943       {
58944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58945       };
58946     } catch (...) {
58947       {
58948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58949       };
58950     }
58951   }
58952 }
58953
58954
58955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
58956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58957   bool arg2 ;
58958
58959   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58960   arg2 = jarg2 ? true : false;
58961   {
58962     try {
58963       (arg1)->SetAsKeyboardFocusGroup(arg2);
58964     } catch (std::out_of_range& e) {
58965       {
58966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58967       };
58968     } catch (std::exception& e) {
58969       {
58970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58971       };
58972     } catch (...) {
58973       {
58974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58975       };
58976     }
58977   }
58978 }
58979
58980
58981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
58982   unsigned int jresult ;
58983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58984   bool result;
58985
58986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58987   {
58988     try {
58989       result = (bool)(arg1)->IsKeyboardFocusGroup();
58990     } catch (std::out_of_range& e) {
58991       {
58992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58993       };
58994     } catch (std::exception& e) {
58995       {
58996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58997       };
58998     } catch (...) {
58999       {
59000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59001       };
59002     }
59003   }
59004   jresult = result;
59005   return jresult;
59006 }
59007
59008
59009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59011
59012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59013   {
59014     try {
59015       (arg1)->AccessibilityActivate();
59016     } catch (std::out_of_range& e) {
59017       {
59018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59019       };
59020     } catch (std::exception& e) {
59021       {
59022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59023       };
59024     } catch (...) {
59025       {
59026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59027       };
59028     }
59029   }
59030 }
59031
59032
59033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59035
59036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59037   {
59038     try {
59039       (arg1)->KeyboardEnter();
59040     } catch (std::out_of_range& e) {
59041       {
59042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59043       };
59044     } catch (std::exception& e) {
59045       {
59046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59047       };
59048     } catch (...) {
59049       {
59050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59051       };
59052     }
59053   }
59054 }
59055
59056
59057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59058   void * jresult ;
59059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59060   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59061
59062   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59063   {
59064     try {
59065       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59066     } catch (std::out_of_range& e) {
59067       {
59068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59069       };
59070     } catch (std::exception& e) {
59071       {
59072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59073       };
59074     } catch (...) {
59075       {
59076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59077       };
59078     }
59079   }
59080   jresult = (void *)result;
59081   return jresult;
59082 }
59083
59084
59085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59086   void * jresult ;
59087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59088   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59089
59090   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59091   {
59092     try {
59093       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59094     } catch (std::out_of_range& e) {
59095       {
59096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59097       };
59098     } catch (std::exception& e) {
59099       {
59100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59101       };
59102     } catch (...) {
59103       {
59104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59105       };
59106     }
59107   }
59108   jresult = (void *)result;
59109   return jresult;
59110 }
59111
59112
59113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59114   void * jresult ;
59115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59116   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59117
59118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59119   {
59120     try {
59121       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59122     } catch (std::out_of_range& e) {
59123       {
59124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59125       };
59126     } catch (std::exception& e) {
59127       {
59128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59129       };
59130     } catch (...) {
59131       {
59132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59133       };
59134     }
59135   }
59136   jresult = (void *)result;
59137   return jresult;
59138 }
59139
59140
59141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59142   unsigned int jresult ;
59143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59144   Dali::KeyEvent *arg2 = 0 ;
59145   bool result;
59146
59147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59148   arg2 = (Dali::KeyEvent *)jarg2;
59149   if (!arg2) {
59150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59151     return 0;
59152   }
59153   {
59154     try {
59155       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59156     } catch (std::out_of_range& e) {
59157       {
59158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59159       };
59160     } catch (std::exception& e) {
59161       {
59162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59163       };
59164     } catch (...) {
59165       {
59166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59167       };
59168     }
59169   }
59170   jresult = result;
59171   return jresult;
59172 }
59173
59174
59175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59177   int arg2 ;
59178   SwigDirector_ViewImpl *darg = 0;
59179
59180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59181   arg2 = (int)jarg2;
59182   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59183   {
59184     try {
59185       (darg)->OnStageConnection(arg2);
59186     } catch (std::out_of_range& e) {
59187       {
59188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59189       };
59190     } catch (std::exception& e) {
59191       {
59192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59193       };
59194     } catch (...) {
59195       {
59196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59197       };
59198     }
59199   }
59200 }
59201
59202
59203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59205   int arg2 ;
59206   SwigDirector_ViewImpl *darg = 0;
59207
59208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59209   arg2 = (int)jarg2;
59210   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59211   {
59212     try {
59213       (darg)->OnStageConnectionSwigPublic(arg2);
59214     } catch (std::out_of_range& e) {
59215       {
59216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59217       };
59218     } catch (std::exception& e) {
59219       {
59220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59221       };
59222     } catch (...) {
59223       {
59224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59225       };
59226     }
59227   }
59228 }
59229
59230
59231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59233   SwigDirector_ViewImpl *darg = 0;
59234
59235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59236   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59237   {
59238     try {
59239       (darg)->OnStageDisconnection();
59240     } catch (std::out_of_range& e) {
59241       {
59242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59243       };
59244     } catch (std::exception& e) {
59245       {
59246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59247       };
59248     } catch (...) {
59249       {
59250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59251       };
59252     }
59253   }
59254 }
59255
59256
59257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59259   SwigDirector_ViewImpl *darg = 0;
59260
59261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59262   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59263   {
59264     try {
59265       (darg)->OnStageDisconnectionSwigPublic();
59266     } catch (std::out_of_range& e) {
59267       {
59268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59269       };
59270     } catch (std::exception& e) {
59271       {
59272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59273       };
59274     } catch (...) {
59275       {
59276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59277       };
59278     }
59279   }
59280 }
59281
59282
59283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59285   Dali::Actor *arg2 = 0 ;
59286   SwigDirector_ViewImpl *darg = 0;
59287
59288   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59289   arg2 = (Dali::Actor *)jarg2;
59290   if (!arg2) {
59291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59292     return ;
59293   }
59294   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59295   {
59296     try {
59297       (darg)->OnChildAdd(*arg2);
59298     } catch (std::out_of_range& e) {
59299       {
59300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59301       };
59302     } catch (std::exception& e) {
59303       {
59304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59305       };
59306     } catch (...) {
59307       {
59308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59309       };
59310     }
59311   }
59312 }
59313
59314
59315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59317   Dali::Actor *arg2 = 0 ;
59318   SwigDirector_ViewImpl *darg = 0;
59319
59320   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59321   arg2 = (Dali::Actor *)jarg2;
59322   if (!arg2) {
59323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59324     return ;
59325   }
59326   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59327   {
59328     try {
59329       (darg)->OnChildAddSwigPublic(*arg2);
59330     } catch (std::out_of_range& e) {
59331       {
59332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59333       };
59334     } catch (std::exception& e) {
59335       {
59336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59337       };
59338     } catch (...) {
59339       {
59340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59341       };
59342     }
59343   }
59344 }
59345
59346
59347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59348   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59349   Dali::Actor *arg2 = 0 ;
59350   SwigDirector_ViewImpl *darg = 0;
59351
59352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59353   arg2 = (Dali::Actor *)jarg2;
59354   if (!arg2) {
59355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59356     return ;
59357   }
59358   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59359   {
59360     try {
59361       (darg)->OnChildRemove(*arg2);
59362     } catch (std::out_of_range& e) {
59363       {
59364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59365       };
59366     } catch (std::exception& e) {
59367       {
59368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59369       };
59370     } catch (...) {
59371       {
59372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59373       };
59374     }
59375   }
59376 }
59377
59378
59379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59381   Dali::Actor *arg2 = 0 ;
59382   SwigDirector_ViewImpl *darg = 0;
59383
59384   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59385   arg2 = (Dali::Actor *)jarg2;
59386   if (!arg2) {
59387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59388     return ;
59389   }
59390   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59391   {
59392     try {
59393       (darg)->OnChildRemoveSwigPublic(*arg2);
59394     } catch (std::out_of_range& e) {
59395       {
59396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59397       };
59398     } catch (std::exception& e) {
59399       {
59400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59401       };
59402     } catch (...) {
59403       {
59404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59405       };
59406     }
59407   }
59408 }
59409
59410
59411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
59412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59413   Dali::Property::Index arg2 ;
59414   Dali::Property::Value arg3 ;
59415   Dali::Property::Value *argp3 ;
59416   SwigDirector_ViewImpl *darg = 0;
59417
59418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59419   arg2 = (Dali::Property::Index)jarg2;
59420   argp3 = (Dali::Property::Value *)jarg3;
59421   if (!argp3) {
59422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59423     return ;
59424   }
59425   arg3 = *argp3;
59426   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59427   {
59428     try {
59429       (darg)->OnPropertySet(arg2,arg3);
59430     } catch (std::out_of_range& e) {
59431       {
59432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59433       };
59434     } catch (std::exception& e) {
59435       {
59436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59437       };
59438     } catch (...) {
59439       {
59440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59441       };
59442     }
59443   }
59444 }
59445
59446
59447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
59448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59449   Dali::Property::Index arg2 ;
59450   Dali::Property::Value arg3 ;
59451   Dali::Property::Value *argp3 ;
59452   SwigDirector_ViewImpl *darg = 0;
59453
59454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59455   arg2 = (Dali::Property::Index)jarg2;
59456   argp3 = (Dali::Property::Value *)jarg3;
59457   if (!argp3) {
59458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59459     return ;
59460   }
59461   arg3 = *argp3;
59462   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59463   {
59464     try {
59465       (darg)->OnPropertySetSwigPublic(arg2,arg3);
59466     } catch (std::out_of_range& e) {
59467       {
59468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59469       };
59470     } catch (std::exception& e) {
59471       {
59472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59473       };
59474     } catch (...) {
59475       {
59476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59477       };
59478     }
59479   }
59480 }
59481
59482
59483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
59484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59485   Dali::Vector3 *arg2 = 0 ;
59486   SwigDirector_ViewImpl *darg = 0;
59487
59488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59489   arg2 = (Dali::Vector3 *)jarg2;
59490   if (!arg2) {
59491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59492     return ;
59493   }
59494   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59495   {
59496     try {
59497       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
59498     } catch (std::out_of_range& e) {
59499       {
59500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59501       };
59502     } catch (std::exception& e) {
59503       {
59504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59505       };
59506     } catch (...) {
59507       {
59508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59509       };
59510     }
59511   }
59512 }
59513
59514
59515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59516   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59517   Dali::Vector3 *arg2 = 0 ;
59518   SwigDirector_ViewImpl *darg = 0;
59519
59520   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59521   arg2 = (Dali::Vector3 *)jarg2;
59522   if (!arg2) {
59523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59524     return ;
59525   }
59526   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59527   {
59528     try {
59529       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
59530     } catch (std::out_of_range& e) {
59531       {
59532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59533       };
59534     } catch (std::exception& e) {
59535       {
59536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59537       };
59538     } catch (...) {
59539       {
59540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59541       };
59542     }
59543   }
59544 }
59545
59546
59547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
59548   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59549   Dali::Animation *arg2 = 0 ;
59550   Dali::Vector3 *arg3 = 0 ;
59551   SwigDirector_ViewImpl *darg = 0;
59552
59553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59554   arg2 = (Dali::Animation *)jarg2;
59555   if (!arg2) {
59556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
59557     return ;
59558   }
59559   arg3 = (Dali::Vector3 *)jarg3;
59560   if (!arg3) {
59561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59562     return ;
59563   }
59564   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59565   {
59566     try {
59567       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
59568     } catch (std::out_of_range& e) {
59569       {
59570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59571       };
59572     } catch (std::exception& e) {
59573       {
59574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59575       };
59576     } catch (...) {
59577       {
59578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59579       };
59580     }
59581   }
59582 }
59583
59584
59585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
59586   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59587   Dali::Animation *arg2 = 0 ;
59588   Dali::Vector3 *arg3 = 0 ;
59589   SwigDirector_ViewImpl *darg = 0;
59590
59591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59592   arg2 = (Dali::Animation *)jarg2;
59593   if (!arg2) {
59594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
59595     return ;
59596   }
59597   arg3 = (Dali::Vector3 *)jarg3;
59598   if (!arg3) {
59599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59600     return ;
59601   }
59602   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59603   {
59604     try {
59605       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
59606     } catch (std::out_of_range& e) {
59607       {
59608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59609       };
59610     } catch (std::exception& e) {
59611       {
59612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59613       };
59614     } catch (...) {
59615       {
59616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59617       };
59618     }
59619   }
59620 }
59621
59622
59623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
59624   unsigned int jresult ;
59625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59626   Dali::TouchEvent *arg2 = 0 ;
59627   SwigDirector_ViewImpl *darg = 0;
59628   bool result;
59629
59630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59631   arg2 = (Dali::TouchEvent *)jarg2;
59632   if (!arg2) {
59633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59634     return 0;
59635   }
59636   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59637   {
59638     try {
59639       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
59640     } catch (std::out_of_range& e) {
59641       {
59642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59643       };
59644     } catch (std::exception& e) {
59645       {
59646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59647       };
59648     } catch (...) {
59649       {
59650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59651       };
59652     }
59653   }
59654   jresult = result;
59655   return jresult;
59656 }
59657
59658
59659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59660   unsigned int jresult ;
59661   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59662   Dali::TouchEvent *arg2 = 0 ;
59663   SwigDirector_ViewImpl *darg = 0;
59664   bool result;
59665
59666   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59667   arg2 = (Dali::TouchEvent *)jarg2;
59668   if (!arg2) {
59669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59670     return 0;
59671   }
59672   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59673   {
59674     try {
59675       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
59676     } catch (std::out_of_range& e) {
59677       {
59678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59679       };
59680     } catch (std::exception& e) {
59681       {
59682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59683       };
59684     } catch (...) {
59685       {
59686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59687       };
59688     }
59689   }
59690   jresult = result;
59691   return jresult;
59692 }
59693
59694
59695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
59696   unsigned int jresult ;
59697   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59698   Dali::HoverEvent *arg2 = 0 ;
59699   SwigDirector_ViewImpl *darg = 0;
59700   bool result;
59701
59702   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59703   arg2 = (Dali::HoverEvent *)jarg2;
59704   if (!arg2) {
59705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
59706     return 0;
59707   }
59708   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59709   {
59710     try {
59711       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
59712     } catch (std::out_of_range& e) {
59713       {
59714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59715       };
59716     } catch (std::exception& e) {
59717       {
59718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59719       };
59720     } catch (...) {
59721       {
59722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59723       };
59724     }
59725   }
59726   jresult = result;
59727   return jresult;
59728 }
59729
59730
59731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59732   unsigned int jresult ;
59733   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59734   Dali::HoverEvent *arg2 = 0 ;
59735   SwigDirector_ViewImpl *darg = 0;
59736   bool result;
59737
59738   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59739   arg2 = (Dali::HoverEvent *)jarg2;
59740   if (!arg2) {
59741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
59742     return 0;
59743   }
59744   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59745   {
59746     try {
59747       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
59748     } catch (std::out_of_range& e) {
59749       {
59750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59751       };
59752     } catch (std::exception& e) {
59753       {
59754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59755       };
59756     } catch (...) {
59757       {
59758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59759       };
59760     }
59761   }
59762   jresult = result;
59763   return jresult;
59764 }
59765
59766
59767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
59768   unsigned int jresult ;
59769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59770   Dali::KeyEvent *arg2 = 0 ;
59771   SwigDirector_ViewImpl *darg = 0;
59772   bool result;
59773
59774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59775   arg2 = (Dali::KeyEvent *)jarg2;
59776   if (!arg2) {
59777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59778     return 0;
59779   }
59780   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59781   {
59782     try {
59783       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
59784     } catch (std::out_of_range& e) {
59785       {
59786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59787       };
59788     } catch (std::exception& e) {
59789       {
59790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59791       };
59792     } catch (...) {
59793       {
59794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59795       };
59796     }
59797   }
59798   jresult = result;
59799   return jresult;
59800 }
59801
59802
59803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59804   unsigned int jresult ;
59805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59806   Dali::KeyEvent *arg2 = 0 ;
59807   SwigDirector_ViewImpl *darg = 0;
59808   bool result;
59809
59810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59811   arg2 = (Dali::KeyEvent *)jarg2;
59812   if (!arg2) {
59813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59814     return 0;
59815   }
59816   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59817   {
59818     try {
59819       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
59820     } catch (std::out_of_range& e) {
59821       {
59822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59823       };
59824     } catch (std::exception& e) {
59825       {
59826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59827       };
59828     } catch (...) {
59829       {
59830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59831       };
59832     }
59833   }
59834   jresult = result;
59835   return jresult;
59836 }
59837
59838
59839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
59840   unsigned int jresult ;
59841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59842   Dali::WheelEvent *arg2 = 0 ;
59843   SwigDirector_ViewImpl *darg = 0;
59844   bool result;
59845
59846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59847   arg2 = (Dali::WheelEvent *)jarg2;
59848   if (!arg2) {
59849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
59850     return 0;
59851   }
59852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59853   {
59854     try {
59855       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
59856     } catch (std::out_of_range& e) {
59857       {
59858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59859       };
59860     } catch (std::exception& e) {
59861       {
59862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59863       };
59864     } catch (...) {
59865       {
59866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59867       };
59868     }
59869   }
59870   jresult = result;
59871   return jresult;
59872 }
59873
59874
59875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59876   unsigned int jresult ;
59877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59878   Dali::WheelEvent *arg2 = 0 ;
59879   SwigDirector_ViewImpl *darg = 0;
59880   bool result;
59881
59882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59883   arg2 = (Dali::WheelEvent *)jarg2;
59884   if (!arg2) {
59885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
59886     return 0;
59887   }
59888   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59889   {
59890     try {
59891       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
59892     } catch (std::out_of_range& e) {
59893       {
59894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59895       };
59896     } catch (std::exception& e) {
59897       {
59898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59899       };
59900     } catch (...) {
59901       {
59902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59903       };
59904     }
59905   }
59906   jresult = result;
59907   return jresult;
59908 }
59909
59910
59911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
59912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59913   Dali::Vector2 *arg2 = 0 ;
59914   Dali::RelayoutContainer *arg3 = 0 ;
59915   SwigDirector_ViewImpl *darg = 0;
59916
59917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59918   arg2 = (Dali::Vector2 *)jarg2;
59919   if (!arg2) {
59920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
59921     return ;
59922   }
59923   arg3 = (Dali::RelayoutContainer *)jarg3;
59924   if (!arg3) {
59925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
59926     return ;
59927   }
59928   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59929   {
59930     try {
59931       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
59932     } catch (std::out_of_range& e) {
59933       {
59934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59935       };
59936     } catch (std::exception& e) {
59937       {
59938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59939       };
59940     } catch (...) {
59941       {
59942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59943       };
59944     }
59945   }
59946 }
59947
59948
59949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
59950   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59951   Dali::Vector2 *arg2 = 0 ;
59952   Dali::RelayoutContainer *arg3 = 0 ;
59953   SwigDirector_ViewImpl *darg = 0;
59954
59955   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59956   arg2 = (Dali::Vector2 *)jarg2;
59957   if (!arg2) {
59958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
59959     return ;
59960   }
59961   arg3 = (Dali::RelayoutContainer *)jarg3;
59962   if (!arg3) {
59963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
59964     return ;
59965   }
59966   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59967   {
59968     try {
59969       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
59970     } catch (std::out_of_range& e) {
59971       {
59972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59973       };
59974     } catch (std::exception& e) {
59975       {
59976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59977       };
59978     } catch (...) {
59979       {
59980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59981       };
59982     }
59983   }
59984 }
59985
59986
59987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
59988   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59989   Dali::ResizePolicy::Type arg2 ;
59990   Dali::Dimension::Type arg3 ;
59991   SwigDirector_ViewImpl *darg = 0;
59992
59993   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59994   arg2 = (Dali::ResizePolicy::Type)jarg2;
59995   arg3 = (Dali::Dimension::Type)jarg3;
59996   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59997   {
59998     try {
59999       (darg)->OnSetResizePolicy(arg2,arg3);
60000     } catch (std::out_of_range& e) {
60001       {
60002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60003       };
60004     } catch (std::exception& e) {
60005       {
60006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60007       };
60008     } catch (...) {
60009       {
60010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60011       };
60012     }
60013   }
60014 }
60015
60016
60017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60018   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60019   Dali::ResizePolicy::Type arg2 ;
60020   Dali::Dimension::Type arg3 ;
60021   SwigDirector_ViewImpl *darg = 0;
60022
60023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60024   arg2 = (Dali::ResizePolicy::Type)jarg2;
60025   arg3 = (Dali::Dimension::Type)jarg3;
60026   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60027   {
60028     try {
60029       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60030     } catch (std::out_of_range& e) {
60031       {
60032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60033       };
60034     } catch (std::exception& e) {
60035       {
60036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60037       };
60038     } catch (...) {
60039       {
60040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60041       };
60042     }
60043   }
60044 }
60045
60046
60047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60048   void * jresult ;
60049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60050   SwigDirector_ViewImpl *darg = 0;
60051   Dali::Vector3 result;
60052
60053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60054   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60055   {
60056     try {
60057       result = (darg)->GetNaturalSize();
60058     } catch (std::out_of_range& e) {
60059       {
60060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60061       };
60062     } catch (std::exception& e) {
60063       {
60064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60065       };
60066     } catch (...) {
60067       {
60068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60069       };
60070     }
60071   }
60072   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60073   return jresult;
60074 }
60075
60076
60077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60078   void * jresult ;
60079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60080   SwigDirector_ViewImpl *darg = 0;
60081   Dali::Vector3 result;
60082
60083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60084   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60085   {
60086     try {
60087       result = (darg)->GetNaturalSizeSwigPublic();
60088     } catch (std::out_of_range& e) {
60089       {
60090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (std::exception& e) {
60093       {
60094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60099       };
60100     }
60101   }
60102   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60103   return jresult;
60104 }
60105
60106
60107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60108   float jresult ;
60109   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60110   Dali::Actor *arg2 = 0 ;
60111   Dali::Dimension::Type arg3 ;
60112   SwigDirector_ViewImpl *darg = 0;
60113   float result;
60114
60115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60116   arg2 = (Dali::Actor *)jarg2;
60117   if (!arg2) {
60118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60119     return 0;
60120   }
60121   arg3 = (Dali::Dimension::Type)jarg3;
60122   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60123   {
60124     try {
60125       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60126     } catch (std::out_of_range& e) {
60127       {
60128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60129       };
60130     } catch (std::exception& e) {
60131       {
60132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60133       };
60134     } catch (...) {
60135       {
60136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60137       };
60138     }
60139   }
60140   jresult = result;
60141   return jresult;
60142 }
60143
60144
60145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60146   float jresult ;
60147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60148   Dali::Actor *arg2 = 0 ;
60149   Dali::Dimension::Type arg3 ;
60150   SwigDirector_ViewImpl *darg = 0;
60151   float result;
60152
60153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60154   arg2 = (Dali::Actor *)jarg2;
60155   if (!arg2) {
60156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60157     return 0;
60158   }
60159   arg3 = (Dali::Dimension::Type)jarg3;
60160   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60161   {
60162     try {
60163       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60164     } catch (std::out_of_range& e) {
60165       {
60166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60167       };
60168     } catch (std::exception& e) {
60169       {
60170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60171       };
60172     } catch (...) {
60173       {
60174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60175       };
60176     }
60177   }
60178   jresult = result;
60179   return jresult;
60180 }
60181
60182
60183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60184   float jresult ;
60185   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60186   float arg2 ;
60187   SwigDirector_ViewImpl *darg = 0;
60188   float result;
60189
60190   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60191   arg2 = (float)jarg2;
60192   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60193   {
60194     try {
60195       result = (float)(darg)->GetHeightForWidth(arg2);
60196     } catch (std::out_of_range& e) {
60197       {
60198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60199       };
60200     } catch (std::exception& e) {
60201       {
60202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60203       };
60204     } catch (...) {
60205       {
60206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60207       };
60208     }
60209   }
60210   jresult = result;
60211   return jresult;
60212 }
60213
60214
60215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60216   float jresult ;
60217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60218   float arg2 ;
60219   SwigDirector_ViewImpl *darg = 0;
60220   float result;
60221
60222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60223   arg2 = (float)jarg2;
60224   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60225   {
60226     try {
60227       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60228     } catch (std::out_of_range& e) {
60229       {
60230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60231       };
60232     } catch (std::exception& e) {
60233       {
60234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60235       };
60236     } catch (...) {
60237       {
60238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60239       };
60240     }
60241   }
60242   jresult = result;
60243   return jresult;
60244 }
60245
60246
60247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60248   float jresult ;
60249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60250   float arg2 ;
60251   SwigDirector_ViewImpl *darg = 0;
60252   float result;
60253
60254   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60255   arg2 = (float)jarg2;
60256   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60257   {
60258     try {
60259       result = (float)(darg)->GetWidthForHeight(arg2);
60260     } catch (std::out_of_range& e) {
60261       {
60262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60263       };
60264     } catch (std::exception& e) {
60265       {
60266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60267       };
60268     } catch (...) {
60269       {
60270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60271       };
60272     }
60273   }
60274   jresult = result;
60275   return jresult;
60276 }
60277
60278
60279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60280   float jresult ;
60281   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60282   float arg2 ;
60283   SwigDirector_ViewImpl *darg = 0;
60284   float result;
60285
60286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60287   arg2 = (float)jarg2;
60288   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60289   {
60290     try {
60291       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60292     } catch (std::out_of_range& e) {
60293       {
60294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60295       };
60296     } catch (std::exception& e) {
60297       {
60298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60299       };
60300     } catch (...) {
60301       {
60302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60303       };
60304     }
60305   }
60306   jresult = result;
60307   return jresult;
60308 }
60309
60310
60311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60312   unsigned int jresult ;
60313   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60314   Dali::Dimension::Type arg2 ;
60315   SwigDirector_ViewImpl *darg = 0;
60316   bool result;
60317
60318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60319   arg2 = (Dali::Dimension::Type)jarg2;
60320   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60321   {
60322     try {
60323       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60324     } catch (std::out_of_range& e) {
60325       {
60326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60327       };
60328     } catch (std::exception& e) {
60329       {
60330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60331       };
60332     } catch (...) {
60333       {
60334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60335       };
60336     }
60337   }
60338   jresult = result;
60339   return jresult;
60340 }
60341
60342
60343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
60344   unsigned int jresult ;
60345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60346   Dali::Dimension::Type arg2 ;
60347   SwigDirector_ViewImpl *darg = 0;
60348   bool result;
60349
60350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60351   arg2 = (Dali::Dimension::Type)jarg2;
60352   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60353   {
60354     try {
60355       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
60356     } catch (std::out_of_range& e) {
60357       {
60358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60359       };
60360     } catch (std::exception& e) {
60361       {
60362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60363       };
60364     } catch (...) {
60365       {
60366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60367       };
60368     }
60369   }
60370   jresult = result;
60371   return jresult;
60372 }
60373
60374
60375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
60376   unsigned int jresult ;
60377   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60378   SwigDirector_ViewImpl *darg = 0;
60379   bool result;
60380
60381   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60382   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60383   {
60384     try {
60385       result = (bool)(darg)->RelayoutDependentOnChildren();
60386     } catch (std::out_of_range& e) {
60387       {
60388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60389       };
60390     } catch (std::exception& e) {
60391       {
60392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60393       };
60394     } catch (...) {
60395       {
60396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60397       };
60398     }
60399   }
60400   jresult = result;
60401   return jresult;
60402 }
60403
60404
60405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
60406   unsigned int jresult ;
60407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60408   SwigDirector_ViewImpl *darg = 0;
60409   bool result;
60410
60411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60412   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60413   {
60414     try {
60415       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
60416     } catch (std::out_of_range& e) {
60417       {
60418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60419       };
60420     } catch (std::exception& e) {
60421       {
60422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60423       };
60424     } catch (...) {
60425       {
60426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60427       };
60428     }
60429   }
60430   jresult = result;
60431   return jresult;
60432 }
60433
60434
60435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
60436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60437   Dali::Dimension::Type arg2 ;
60438   SwigDirector_ViewImpl *darg = 0;
60439
60440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60441   arg2 = (Dali::Dimension::Type)jarg2;
60442   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60443   {
60444     try {
60445       (darg)->OnCalculateRelayoutSize(arg2);
60446     } catch (std::out_of_range& e) {
60447       {
60448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60449       };
60450     } catch (std::exception& e) {
60451       {
60452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60453       };
60454     } catch (...) {
60455       {
60456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60457       };
60458     }
60459   }
60460 }
60461
60462
60463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
60464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60465   Dali::Dimension::Type arg2 ;
60466   SwigDirector_ViewImpl *darg = 0;
60467
60468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60469   arg2 = (Dali::Dimension::Type)jarg2;
60470   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60471   {
60472     try {
60473       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
60474     } catch (std::out_of_range& e) {
60475       {
60476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60477       };
60478     } catch (std::exception& e) {
60479       {
60480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60481       };
60482     } catch (...) {
60483       {
60484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60485       };
60486     }
60487   }
60488 }
60489
60490
60491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
60492   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60493   float arg2 ;
60494   Dali::Dimension::Type arg3 ;
60495   SwigDirector_ViewImpl *darg = 0;
60496
60497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60498   arg2 = (float)jarg2;
60499   arg3 = (Dali::Dimension::Type)jarg3;
60500   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60501   {
60502     try {
60503       (darg)->OnLayoutNegotiated(arg2,arg3);
60504     } catch (std::out_of_range& e) {
60505       {
60506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60507       };
60508     } catch (std::exception& e) {
60509       {
60510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60511       };
60512     } catch (...) {
60513       {
60514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60515       };
60516     }
60517   }
60518 }
60519
60520
60521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
60522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60523   float arg2 ;
60524   Dali::Dimension::Type arg3 ;
60525   SwigDirector_ViewImpl *darg = 0;
60526
60527   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60528   arg2 = (float)jarg2;
60529   arg3 = (Dali::Dimension::Type)jarg3;
60530   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60531   {
60532     try {
60533       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
60534     } catch (std::out_of_range& e) {
60535       {
60536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60537       };
60538     } catch (std::exception& e) {
60539       {
60540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60541       };
60542     } catch (...) {
60543       {
60544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60545       };
60546     }
60547   }
60548 }
60549
60550
60551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
60552   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60553
60554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60555   {
60556     try {
60557       (arg1)->OnInitialize();
60558     } catch (std::out_of_range& e) {
60559       {
60560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60561       };
60562     } catch (std::exception& e) {
60563       {
60564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60565       };
60566     } catch (...) {
60567       {
60568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60569       };
60570     }
60571   }
60572 }
60573
60574
60575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
60576   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60577
60578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60579   {
60580     try {
60581       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
60582     } catch (std::out_of_range& e) {
60583       {
60584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60585       };
60586     } catch (std::exception& e) {
60587       {
60588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60589       };
60590     } catch (...) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60593       };
60594     }
60595   }
60596 }
60597
60598
60599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
60600   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60601   Dali::Actor *arg2 = 0 ;
60602
60603   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60604   arg2 = (Dali::Actor *)jarg2;
60605   if (!arg2) {
60606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60607     return ;
60608   }
60609   {
60610     try {
60611       (arg1)->OnControlChildAdd(*arg2);
60612     } catch (std::out_of_range& e) {
60613       {
60614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60615       };
60616     } catch (std::exception& e) {
60617       {
60618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60619       };
60620     } catch (...) {
60621       {
60622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60623       };
60624     }
60625   }
60626 }
60627
60628
60629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60630   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60631   Dali::Actor *arg2 = 0 ;
60632
60633   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60634   arg2 = (Dali::Actor *)jarg2;
60635   if (!arg2) {
60636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60637     return ;
60638   }
60639   {
60640     try {
60641       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
60642     } catch (std::out_of_range& e) {
60643       {
60644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60645       };
60646     } catch (std::exception& e) {
60647       {
60648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60649       };
60650     } catch (...) {
60651       {
60652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60653       };
60654     }
60655   }
60656 }
60657
60658
60659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
60660   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60661   Dali::Actor *arg2 = 0 ;
60662
60663   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60664   arg2 = (Dali::Actor *)jarg2;
60665   if (!arg2) {
60666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60667     return ;
60668   }
60669   {
60670     try {
60671       (arg1)->OnControlChildRemove(*arg2);
60672     } catch (std::out_of_range& e) {
60673       {
60674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60675       };
60676     } catch (std::exception& e) {
60677       {
60678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60679       };
60680     } catch (...) {
60681       {
60682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60683       };
60684     }
60685   }
60686 }
60687
60688
60689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60691   Dali::Actor *arg2 = 0 ;
60692
60693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60694   arg2 = (Dali::Actor *)jarg2;
60695   if (!arg2) {
60696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60697     return ;
60698   }
60699   {
60700     try {
60701       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
60702     } catch (std::out_of_range& e) {
60703       {
60704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60705       };
60706     } catch (std::exception& e) {
60707       {
60708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60709       };
60710     } catch (...) {
60711       {
60712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60713       };
60714     }
60715   }
60716 }
60717
60718
60719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
60720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60721   Dali::Toolkit::StyleManager arg2 ;
60722   Dali::StyleChange::Type arg3 ;
60723   Dali::Toolkit::StyleManager *argp2 ;
60724
60725   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60726   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
60727   if (!argp2) {
60728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
60729     return ;
60730   }
60731   arg2 = *argp2;
60732   arg3 = (Dali::StyleChange::Type)jarg3;
60733   {
60734     try {
60735       (arg1)->OnStyleChange(arg2,arg3);
60736     } catch (std::out_of_range& e) {
60737       {
60738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60739       };
60740     } catch (std::exception& e) {
60741       {
60742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60743       };
60744     } catch (...) {
60745       {
60746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60747       };
60748     }
60749   }
60750 }
60751
60752
60753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60755   Dali::Toolkit::StyleManager arg2 ;
60756   Dali::StyleChange::Type arg3 ;
60757   Dali::Toolkit::StyleManager *argp2 ;
60758
60759   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60760   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
60761   if (!argp2) {
60762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
60763     return ;
60764   }
60765   arg2 = *argp2;
60766   arg3 = (Dali::StyleChange::Type)jarg3;
60767   {
60768     try {
60769       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
60770     } catch (std::out_of_range& e) {
60771       {
60772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60773       };
60774     } catch (std::exception& e) {
60775       {
60776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60777       };
60778     } catch (...) {
60779       {
60780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60781       };
60782     }
60783   }
60784 }
60785
60786
60787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
60788   unsigned int jresult ;
60789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60790   bool result;
60791
60792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60793   {
60794     try {
60795       result = (bool)(arg1)->OnAccessibilityActivated();
60796     } catch (std::out_of_range& e) {
60797       {
60798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60799       };
60800     } catch (std::exception& e) {
60801       {
60802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60803       };
60804     } catch (...) {
60805       {
60806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60807       };
60808     }
60809   }
60810   jresult = result;
60811   return jresult;
60812 }
60813
60814
60815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
60816   unsigned int jresult ;
60817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60818   bool result;
60819
60820   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60821   {
60822     try {
60823       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
60824     } catch (std::out_of_range& e) {
60825       {
60826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60827       };
60828     } catch (std::exception& e) {
60829       {
60830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60831       };
60832     } catch (...) {
60833       {
60834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60835       };
60836     }
60837   }
60838   jresult = result;
60839   return jresult;
60840 }
60841
60842
60843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
60844   unsigned int jresult ;
60845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60846   Dali::PanGesture arg2 ;
60847   Dali::PanGesture *argp2 ;
60848   bool result;
60849
60850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60851   argp2 = (Dali::PanGesture *)jarg2;
60852   if (!argp2) {
60853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
60854     return 0;
60855   }
60856   arg2 = *argp2;
60857   {
60858     try {
60859       result = (bool)(arg1)->OnAccessibilityPan(arg2);
60860     } catch (std::out_of_range& e) {
60861       {
60862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60863       };
60864     } catch (std::exception& e) {
60865       {
60866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60867       };
60868     } catch (...) {
60869       {
60870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60871       };
60872     }
60873   }
60874   jresult = result;
60875   return jresult;
60876 }
60877
60878
60879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60880   unsigned int jresult ;
60881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60882   Dali::PanGesture arg2 ;
60883   Dali::PanGesture *argp2 ;
60884   bool result;
60885
60886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60887   argp2 = (Dali::PanGesture *)jarg2;
60888   if (!argp2) {
60889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
60890     return 0;
60891   }
60892   arg2 = *argp2;
60893   {
60894     try {
60895       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
60896     } catch (std::out_of_range& e) {
60897       {
60898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60899       };
60900     } catch (std::exception& e) {
60901       {
60902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60903       };
60904     } catch (...) {
60905       {
60906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60907       };
60908     }
60909   }
60910   jresult = result;
60911   return jresult;
60912 }
60913
60914
60915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
60916   unsigned int jresult ;
60917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60918   Dali::TouchEvent *arg2 = 0 ;
60919   bool result;
60920
60921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60922   arg2 = (Dali::TouchEvent *)jarg2;
60923   if (!arg2) {
60924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60925     return 0;
60926   }
60927   {
60928     try {
60929       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
60930     } catch (std::out_of_range& e) {
60931       {
60932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60933       };
60934     } catch (std::exception& e) {
60935       {
60936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60937       };
60938     } catch (...) {
60939       {
60940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60941       };
60942     }
60943   }
60944   jresult = result;
60945   return jresult;
60946 }
60947
60948
60949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60950   unsigned int jresult ;
60951   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60952   Dali::TouchEvent *arg2 = 0 ;
60953   bool result;
60954
60955   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60956   arg2 = (Dali::TouchEvent *)jarg2;
60957   if (!arg2) {
60958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60959     return 0;
60960   }
60961   {
60962     try {
60963       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
60964     } catch (std::out_of_range& e) {
60965       {
60966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60967       };
60968     } catch (std::exception& e) {
60969       {
60970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60971       };
60972     } catch (...) {
60973       {
60974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60975       };
60976     }
60977   }
60978   jresult = result;
60979   return jresult;
60980 }
60981
60982
60983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
60984   unsigned int jresult ;
60985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60986   bool arg2 ;
60987   bool result;
60988
60989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60990   arg2 = jarg2 ? true : false;
60991   {
60992     try {
60993       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
60994     } catch (std::out_of_range& e) {
60995       {
60996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60997       };
60998     } catch (std::exception& e) {
60999       {
61000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61001       };
61002     } catch (...) {
61003       {
61004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61005       };
61006     }
61007   }
61008   jresult = result;
61009   return jresult;
61010 }
61011
61012
61013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61014   unsigned int jresult ;
61015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61016   bool arg2 ;
61017   bool result;
61018
61019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61020   arg2 = jarg2 ? true : false;
61021   {
61022     try {
61023       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61024     } catch (std::out_of_range& e) {
61025       {
61026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61027       };
61028     } catch (std::exception& e) {
61029       {
61030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61031       };
61032     } catch (...) {
61033       {
61034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61035       };
61036     }
61037   }
61038   jresult = result;
61039   return jresult;
61040 }
61041
61042
61043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61044   unsigned int jresult ;
61045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61046   bool result;
61047
61048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61049   {
61050     try {
61051       result = (bool)(arg1)->OnAccessibilityZoom();
61052     } catch (std::out_of_range& e) {
61053       {
61054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61055       };
61056     } catch (std::exception& e) {
61057       {
61058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61059       };
61060     } catch (...) {
61061       {
61062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61063       };
61064     }
61065   }
61066   jresult = result;
61067   return jresult;
61068 }
61069
61070
61071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61072   unsigned int jresult ;
61073   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61074   bool result;
61075
61076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61077   {
61078     try {
61079       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61080     } catch (std::out_of_range& e) {
61081       {
61082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61083       };
61084     } catch (std::exception& e) {
61085       {
61086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61087       };
61088     } catch (...) {
61089       {
61090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61091       };
61092     }
61093   }
61094   jresult = result;
61095   return jresult;
61096 }
61097
61098
61099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61101
61102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61103   {
61104     try {
61105       (arg1)->OnKeyInputFocusGained();
61106     } catch (std::out_of_range& e) {
61107       {
61108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61109       };
61110     } catch (std::exception& e) {
61111       {
61112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61113       };
61114     } catch (...) {
61115       {
61116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61117       };
61118     }
61119   }
61120 }
61121
61122
61123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61125
61126   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61127   {
61128     try {
61129       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61130     } catch (std::out_of_range& e) {
61131       {
61132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61133       };
61134     } catch (std::exception& e) {
61135       {
61136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61137       };
61138     } catch (...) {
61139       {
61140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61141       };
61142     }
61143   }
61144 }
61145
61146
61147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61148   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61149
61150   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61151   {
61152     try {
61153       (arg1)->OnKeyInputFocusLost();
61154     } catch (std::out_of_range& e) {
61155       {
61156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61157       };
61158     } catch (std::exception& e) {
61159       {
61160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61161       };
61162     } catch (...) {
61163       {
61164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61165       };
61166     }
61167   }
61168 }
61169
61170
61171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61172   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61173
61174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61175   {
61176     try {
61177       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61178     } catch (std::out_of_range& e) {
61179       {
61180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61181       };
61182     } catch (std::exception& e) {
61183       {
61184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61185       };
61186     } catch (...) {
61187       {
61188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61189       };
61190     }
61191   }
61192 }
61193
61194
61195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61196   void * jresult ;
61197   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61198   Dali::Actor arg2 ;
61199   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61200   bool arg4 ;
61201   Dali::Actor *argp2 ;
61202   Dali::Actor result;
61203
61204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61205   argp2 = (Dali::Actor *)jarg2;
61206   if (!argp2) {
61207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61208     return 0;
61209   }
61210   arg2 = *argp2;
61211   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61212   arg4 = jarg4 ? true : false;
61213   {
61214     try {
61215       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61216     } catch (std::out_of_range& e) {
61217       {
61218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61219       };
61220     } catch (std::exception& e) {
61221       {
61222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61223       };
61224     } catch (...) {
61225       {
61226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61227       };
61228     }
61229   }
61230   jresult = new Dali::Actor((const Dali::Actor &)result);
61231   return jresult;
61232 }
61233
61234
61235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61236   void * jresult ;
61237   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61238   Dali::Actor arg2 ;
61239   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61240   bool arg4 ;
61241   Dali::Actor *argp2 ;
61242   Dali::Actor result;
61243
61244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61245   argp2 = (Dali::Actor *)jarg2;
61246   if (!argp2) {
61247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61248     return 0;
61249   }
61250   arg2 = *argp2;
61251   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61252   arg4 = jarg4 ? true : false;
61253   {
61254     try {
61255       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61256     } catch (std::out_of_range& e) {
61257       {
61258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61259       };
61260     } catch (std::exception& e) {
61261       {
61262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61263       };
61264     } catch (...) {
61265       {
61266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61267       };
61268     }
61269   }
61270   jresult = new Dali::Actor((const Dali::Actor &)result);
61271   return jresult;
61272 }
61273
61274
61275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61277   Dali::Actor arg2 ;
61278   Dali::Actor *argp2 ;
61279
61280   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61281   argp2 = (Dali::Actor *)jarg2;
61282   if (!argp2) {
61283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61284     return ;
61285   }
61286   arg2 = *argp2;
61287   {
61288     try {
61289       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61290     } catch (std::out_of_range& e) {
61291       {
61292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61293       };
61294     } catch (std::exception& e) {
61295       {
61296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61297       };
61298     } catch (...) {
61299       {
61300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61301       };
61302     }
61303   }
61304 }
61305
61306
61307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61309   Dali::Actor arg2 ;
61310   Dali::Actor *argp2 ;
61311
61312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61313   argp2 = (Dali::Actor *)jarg2;
61314   if (!argp2) {
61315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61316     return ;
61317   }
61318   arg2 = *argp2;
61319   {
61320     try {
61321       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61322     } catch (std::out_of_range& e) {
61323       {
61324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61325       };
61326     } catch (std::exception& e) {
61327       {
61328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61329       };
61330     } catch (...) {
61331       {
61332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61333       };
61334     }
61335   }
61336 }
61337
61338
61339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
61340   unsigned int jresult ;
61341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61342   bool result;
61343
61344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61345   {
61346     try {
61347       result = (bool)(arg1)->OnKeyboardEnter();
61348     } catch (std::out_of_range& e) {
61349       {
61350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61351       };
61352     } catch (std::exception& e) {
61353       {
61354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61355       };
61356     } catch (...) {
61357       {
61358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61359       };
61360     }
61361   }
61362   jresult = result;
61363   return jresult;
61364 }
61365
61366
61367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
61368   unsigned int jresult ;
61369   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61370   bool result;
61371
61372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61373   {
61374     try {
61375       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
61376     } catch (std::out_of_range& e) {
61377       {
61378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61379       };
61380     } catch (std::exception& e) {
61381       {
61382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61383       };
61384     } catch (...) {
61385       {
61386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61387       };
61388     }
61389   }
61390   jresult = result;
61391   return jresult;
61392 }
61393
61394
61395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
61396   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61397   Dali::PinchGesture *arg2 = 0 ;
61398
61399   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61400   arg2 = (Dali::PinchGesture *)jarg2;
61401   if (!arg2) {
61402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61403     return ;
61404   }
61405   {
61406     try {
61407       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
61408     } catch (std::out_of_range& e) {
61409       {
61410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61411       };
61412     } catch (std::exception& e) {
61413       {
61414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61415       };
61416     } catch (...) {
61417       {
61418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61419       };
61420     }
61421   }
61422 }
61423
61424
61425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61426   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61427   Dali::PinchGesture *arg2 = 0 ;
61428
61429   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61430   arg2 = (Dali::PinchGesture *)jarg2;
61431   if (!arg2) {
61432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61433     return ;
61434   }
61435   {
61436     try {
61437       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
61438     } catch (std::out_of_range& e) {
61439       {
61440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61441       };
61442     } catch (std::exception& e) {
61443       {
61444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61445       };
61446     } catch (...) {
61447       {
61448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61449       };
61450     }
61451   }
61452 }
61453
61454
61455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
61456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61457   Dali::PanGesture *arg2 = 0 ;
61458
61459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61460   arg2 = (Dali::PanGesture *)jarg2;
61461   if (!arg2) {
61462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61463     return ;
61464   }
61465   {
61466     try {
61467       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
61468     } catch (std::out_of_range& e) {
61469       {
61470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61471       };
61472     } catch (std::exception& e) {
61473       {
61474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61475       };
61476     } catch (...) {
61477       {
61478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61479       };
61480     }
61481   }
61482 }
61483
61484
61485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61486   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61487   Dali::PanGesture *arg2 = 0 ;
61488
61489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61490   arg2 = (Dali::PanGesture *)jarg2;
61491   if (!arg2) {
61492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61493     return ;
61494   }
61495   {
61496     try {
61497       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
61498     } catch (std::out_of_range& e) {
61499       {
61500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61501       };
61502     } catch (std::exception& e) {
61503       {
61504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61505       };
61506     } catch (...) {
61507       {
61508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61509       };
61510     }
61511   }
61512 }
61513
61514
61515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
61516   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61517   Dali::TapGesture *arg2 = 0 ;
61518
61519   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61520   arg2 = (Dali::TapGesture *)jarg2;
61521   if (!arg2) {
61522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61523     return ;
61524   }
61525   {
61526     try {
61527       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
61528     } catch (std::out_of_range& e) {
61529       {
61530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61531       };
61532     } catch (std::exception& e) {
61533       {
61534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61535       };
61536     } catch (...) {
61537       {
61538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61539       };
61540     }
61541   }
61542 }
61543
61544
61545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61547   Dali::TapGesture *arg2 = 0 ;
61548
61549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61550   arg2 = (Dali::TapGesture *)jarg2;
61551   if (!arg2) {
61552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61553     return ;
61554   }
61555   {
61556     try {
61557       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
61558     } catch (std::out_of_range& e) {
61559       {
61560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61561       };
61562     } catch (std::exception& e) {
61563       {
61564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61565       };
61566     } catch (...) {
61567       {
61568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61569       };
61570     }
61571   }
61572 }
61573
61574
61575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
61576   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61577   Dali::LongPressGesture *arg2 = 0 ;
61578
61579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61580   arg2 = (Dali::LongPressGesture *)jarg2;
61581   if (!arg2) {
61582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
61583     return ;
61584   }
61585   {
61586     try {
61587       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
61588     } catch (std::out_of_range& e) {
61589       {
61590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61591       };
61592     } catch (std::exception& e) {
61593       {
61594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61595       };
61596     } catch (...) {
61597       {
61598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61599       };
61600     }
61601   }
61602 }
61603
61604
61605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61606   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61607   Dali::LongPressGesture *arg2 = 0 ;
61608
61609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61610   arg2 = (Dali::LongPressGesture *)jarg2;
61611   if (!arg2) {
61612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
61613     return ;
61614   }
61615   {
61616     try {
61617       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
61618     } catch (std::out_of_range& e) {
61619       {
61620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61621       };
61622     } catch (std::exception& e) {
61623       {
61624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61625       };
61626     } catch (...) {
61627       {
61628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61629       };
61630     }
61631   }
61632 }
61633
61634
61635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
61636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61637   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61638   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61639
61640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61641   arg2 = (Dali::SlotObserver *)jarg2;
61642   arg3 = (Dali::CallbackBase *)jarg3;
61643   {
61644     try {
61645       (arg1)->SignalConnected(arg2,arg3);
61646     } catch (std::out_of_range& e) {
61647       {
61648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61649       };
61650     } catch (std::exception& e) {
61651       {
61652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61653       };
61654     } catch (...) {
61655       {
61656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61657       };
61658     }
61659   }
61660 }
61661
61662
61663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61665   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61666   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61667
61668   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61669   arg2 = (Dali::SlotObserver *)jarg2;
61670   arg3 = (Dali::CallbackBase *)jarg3;
61671   {
61672     try {
61673       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
61674     } catch (std::out_of_range& e) {
61675       {
61676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61677       };
61678     } catch (std::exception& e) {
61679       {
61680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61681       };
61682     } catch (...) {
61683       {
61684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61685       };
61686     }
61687   }
61688 }
61689
61690
61691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
61692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61693   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61694   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61695
61696   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61697   arg2 = (Dali::SlotObserver *)jarg2;
61698   arg3 = (Dali::CallbackBase *)jarg3;
61699   {
61700     try {
61701       (arg1)->SignalDisconnected(arg2,arg3);
61702     } catch (std::out_of_range& e) {
61703       {
61704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61705       };
61706     } catch (std::exception& e) {
61707       {
61708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61709       };
61710     } catch (...) {
61711       {
61712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61713       };
61714     }
61715   }
61716 }
61717
61718
61719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61721   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61722   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61723
61724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61725   arg2 = (Dali::SlotObserver *)jarg2;
61726   arg3 = (Dali::CallbackBase *)jarg3;
61727   {
61728     try {
61729       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
61730     } catch (std::out_of_range& e) {
61731       {
61732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61733       };
61734     } catch (std::exception& e) {
61735       {
61736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61737       };
61738     } catch (...) {
61739       {
61740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61741       };
61742     }
61743   }
61744 }
61745
61746
61747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback7_t callback7, SwigDirector_ViewImpl::SWIG_Callback8_t callback8, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback10_t callback10, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback22_t callback22, SwigDirector_ViewImpl::SWIG_Callback23_t callback23, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback27_t callback27, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
61748   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
61749   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
61750   if (director) {
61751     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
61752   }
61753 }
61754
61755
61756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
61757   void * jresult ;
61758   Dali::Toolkit::Control *arg1 = 0 ;
61759   Dali::Toolkit::Internal::Control *result = 0 ;
61760
61761   arg1 = (Dali::Toolkit::Control *)jarg1;
61762   if (!arg1) {
61763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
61764     return 0;
61765   }
61766   {
61767     try {
61768       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
61769     } catch (std::out_of_range& e) {
61770       {
61771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61772       };
61773     } catch (std::exception& e) {
61774       {
61775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61776       };
61777     } catch (...) {
61778       {
61779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61780       };
61781     }
61782   }
61783   jresult = (void *)result;
61784   return jresult;
61785 }
61786
61787
61788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
61789   int jresult ;
61790   int result;
61791
61792   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
61793   jresult = (int)result;
61794   return jresult;
61795 }
61796
61797
61798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
61799   int jresult ;
61800   int result;
61801
61802   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
61803   jresult = (int)result;
61804   return jresult;
61805 }
61806
61807
61808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
61809   int jresult ;
61810   int result;
61811
61812   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
61813   jresult = (int)result;
61814   return jresult;
61815 }
61816
61817
61818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
61819   int jresult ;
61820   int result;
61821
61822   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
61823   jresult = (int)result;
61824   return jresult;
61825 }
61826
61827
61828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
61829   int jresult ;
61830   int result;
61831
61832   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
61833   jresult = (int)result;
61834   return jresult;
61835 }
61836
61837
61838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
61839   void * jresult ;
61840   Dali::Toolkit::Control::Property *result = 0 ;
61841
61842   {
61843     try {
61844       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
61845     } catch (std::out_of_range& e) {
61846       {
61847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61848       };
61849     } catch (std::exception& e) {
61850       {
61851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61852       };
61853     } catch (...) {
61854       {
61855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61856       };
61857     }
61858   }
61859   jresult = (void *)result;
61860   return jresult;
61861 }
61862
61863
61864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
61865   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
61866
61867   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
61868   {
61869     try {
61870       delete arg1;
61871     } catch (std::out_of_range& e) {
61872       {
61873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61874       };
61875     } catch (std::exception& e) {
61876       {
61877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61878       };
61879     } catch (...) {
61880       {
61881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61882       };
61883     }
61884   }
61885 }
61886
61887
61888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
61889   void * jresult ;
61890   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
61891
61892   {
61893     try {
61894       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
61895     } catch (std::out_of_range& e) {
61896       {
61897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61898       };
61899     } catch (std::exception& e) {
61900       {
61901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61902       };
61903     } catch (...) {
61904       {
61905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61906       };
61907     }
61908   }
61909   jresult = (void *)result;
61910   return jresult;
61911 }
61912
61913
61914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
61915   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
61916
61917   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
61918   {
61919     try {
61920       delete arg1;
61921     } catch (std::out_of_range& e) {
61922       {
61923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61924       };
61925     } catch (std::exception& e) {
61926       {
61927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61928       };
61929     } catch (...) {
61930       {
61931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61932       };
61933     }
61934   }
61935 }
61936
61937
61938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
61939   void * jresult ;
61940   Dali::Toolkit::Control result;
61941
61942   {
61943     try {
61944       result = Dali::Toolkit::Control::New();
61945     } catch (std::out_of_range& e) {
61946       {
61947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61948       };
61949     } catch (std::exception& e) {
61950       {
61951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61952       };
61953     } catch (...) {
61954       {
61955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61956       };
61957     }
61958   }
61959   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
61960   return jresult;
61961 }
61962
61963
61964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
61965   void * jresult ;
61966   Dali::Toolkit::Control *result = 0 ;
61967
61968   {
61969     try {
61970       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
61971     } catch (std::out_of_range& e) {
61972       {
61973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61974       };
61975     } catch (std::exception& e) {
61976       {
61977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61978       };
61979     } catch (...) {
61980       {
61981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61982       };
61983     }
61984   }
61985   jresult = (void *)result;
61986   return jresult;
61987 }
61988
61989
61990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
61991   void * jresult ;
61992   Dali::Toolkit::Control *arg1 = 0 ;
61993   Dali::Toolkit::Control *result = 0 ;
61994
61995   arg1 = (Dali::Toolkit::Control *)jarg1;
61996   if (!arg1) {
61997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
61998     return 0;
61999   }
62000   {
62001     try {
62002       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62003     } catch (std::out_of_range& e) {
62004       {
62005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62006       };
62007     } catch (std::exception& e) {
62008       {
62009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62010       };
62011     } catch (...) {
62012       {
62013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62014       };
62015     }
62016   }
62017   jresult = (void *)result;
62018   return jresult;
62019 }
62020
62021
62022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62023   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62024
62025   arg1 = (Dali::Toolkit::Control *)jarg1;
62026   {
62027     try {
62028       delete arg1;
62029     } catch (std::out_of_range& e) {
62030       {
62031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62032       };
62033     } catch (std::exception& e) {
62034       {
62035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62036       };
62037     } catch (...) {
62038       {
62039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62040       };
62041     }
62042   }
62043 }
62044
62045
62046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62047   void * jresult ;
62048   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62049   Dali::Toolkit::Control *arg2 = 0 ;
62050   Dali::Toolkit::Control *result = 0 ;
62051
62052   arg1 = (Dali::Toolkit::Control *)jarg1;
62053   arg2 = (Dali::Toolkit::Control *)jarg2;
62054   if (!arg2) {
62055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62056     return 0;
62057   }
62058   {
62059     try {
62060       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62061     } catch (std::out_of_range& e) {
62062       {
62063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62064       };
62065     } catch (std::exception& e) {
62066       {
62067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62068       };
62069     } catch (...) {
62070       {
62071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62072       };
62073     }
62074   }
62075   jresult = (void *)result;
62076   return jresult;
62077 }
62078
62079
62080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62081   void * jresult ;
62082   Dali::BaseHandle arg1 ;
62083   Dali::BaseHandle *argp1 ;
62084   Dali::Toolkit::Control result;
62085
62086   argp1 = (Dali::BaseHandle *)jarg1;
62087   if (!argp1) {
62088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62089     return 0;
62090   }
62091   arg1 = *argp1;
62092   {
62093     try {
62094       result = Dali::Toolkit::Control::DownCast(arg1);
62095     } catch (std::out_of_range& e) {
62096       {
62097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62098       };
62099     } catch (std::exception& e) {
62100       {
62101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62102       };
62103     } catch (...) {
62104       {
62105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62106       };
62107     }
62108   }
62109   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62110   return jresult;
62111 }
62112
62113
62114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62115   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62116
62117   arg1 = (Dali::Toolkit::Control *)jarg1;
62118   {
62119     try {
62120       (arg1)->SetKeyInputFocus();
62121     } catch (std::out_of_range& e) {
62122       {
62123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62124       };
62125     } catch (std::exception& e) {
62126       {
62127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62128       };
62129     } catch (...) {
62130       {
62131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62132       };
62133     }
62134   }
62135 }
62136
62137
62138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62139   unsigned int jresult ;
62140   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62141   bool result;
62142
62143   arg1 = (Dali::Toolkit::Control *)jarg1;
62144   {
62145     try {
62146       result = (bool)(arg1)->HasKeyInputFocus();
62147     } catch (std::out_of_range& e) {
62148       {
62149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62150       };
62151     } catch (std::exception& e) {
62152       {
62153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62154       };
62155     } catch (...) {
62156       {
62157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62158       };
62159     }
62160   }
62161   jresult = result;
62162   return jresult;
62163 }
62164
62165
62166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62167   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62168
62169   arg1 = (Dali::Toolkit::Control *)jarg1;
62170   {
62171     try {
62172       (arg1)->ClearKeyInputFocus();
62173     } catch (std::out_of_range& e) {
62174       {
62175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62176       };
62177     } catch (std::exception& e) {
62178       {
62179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62180       };
62181     } catch (...) {
62182       {
62183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62184       };
62185     }
62186   }
62187 }
62188
62189
62190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62191   void * jresult ;
62192   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62193   Dali::PinchGestureDetector result;
62194
62195   arg1 = (Dali::Toolkit::Control *)jarg1;
62196   {
62197     try {
62198       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62199     } catch (std::out_of_range& e) {
62200       {
62201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62202       };
62203     } catch (std::exception& e) {
62204       {
62205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62206       };
62207     } catch (...) {
62208       {
62209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62210       };
62211     }
62212   }
62213   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62214   return jresult;
62215 }
62216
62217
62218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62219   void * jresult ;
62220   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62221   Dali::PanGestureDetector result;
62222
62223   arg1 = (Dali::Toolkit::Control *)jarg1;
62224   {
62225     try {
62226       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62227     } catch (std::out_of_range& e) {
62228       {
62229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62230       };
62231     } catch (std::exception& e) {
62232       {
62233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62234       };
62235     } catch (...) {
62236       {
62237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62238       };
62239     }
62240   }
62241   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62242   return jresult;
62243 }
62244
62245
62246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62247   void * jresult ;
62248   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62249   Dali::TapGestureDetector result;
62250
62251   arg1 = (Dali::Toolkit::Control *)jarg1;
62252   {
62253     try {
62254       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62255     } catch (std::out_of_range& e) {
62256       {
62257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62258       };
62259     } catch (std::exception& e) {
62260       {
62261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62262       };
62263     } catch (...) {
62264       {
62265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62266       };
62267     }
62268   }
62269   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62270   return jresult;
62271 }
62272
62273
62274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62275   void * jresult ;
62276   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62277   Dali::LongPressGestureDetector result;
62278
62279   arg1 = (Dali::Toolkit::Control *)jarg1;
62280   {
62281     try {
62282       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62283     } catch (std::out_of_range& e) {
62284       {
62285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62286       };
62287     } catch (std::exception& e) {
62288       {
62289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62290       };
62291     } catch (...) {
62292       {
62293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62294       };
62295     }
62296   }
62297   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62298   return jresult;
62299 }
62300
62301
62302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62303   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62304   std::string *arg2 = 0 ;
62305
62306   arg1 = (Dali::Toolkit::Control *)jarg1;
62307   if (!jarg2) {
62308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62309     return ;
62310   }
62311   std::string arg2_str(jarg2);
62312   arg2 = &arg2_str;
62313   {
62314     try {
62315       (arg1)->SetStyleName((std::string const &)*arg2);
62316     } catch (std::out_of_range& e) {
62317       {
62318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62319       };
62320     } catch (std::exception& e) {
62321       {
62322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62323       };
62324     } catch (...) {
62325       {
62326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62327       };
62328     }
62329   }
62330
62331   //argout typemap for const std::string&
62332
62333 }
62334
62335
62336 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62337   char * jresult ;
62338   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62339   std::string *result = 0 ;
62340
62341   arg1 = (Dali::Toolkit::Control *)jarg1;
62342   {
62343     try {
62344       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
62345     } catch (std::out_of_range& e) {
62346       {
62347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62348       };
62349     } catch (std::exception& e) {
62350       {
62351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62352       };
62353     } catch (...) {
62354       {
62355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62356       };
62357     }
62358   }
62359   jresult = SWIG_csharp_string_callback(result->c_str());
62360   return jresult;
62361 }
62362
62363
62364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
62365   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62366   Dali::Vector4 *arg2 = 0 ;
62367
62368   arg1 = (Dali::Toolkit::Control *)jarg1;
62369   arg2 = (Dali::Vector4 *)jarg2;
62370   if (!arg2) {
62371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62372     return ;
62373   }
62374   {
62375     try {
62376       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62377     } catch (std::out_of_range& e) {
62378       {
62379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62380       };
62381     } catch (std::exception& e) {
62382       {
62383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62384       };
62385     } catch (...) {
62386       {
62387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62388       };
62389     }
62390   }
62391 }
62392
62393
62394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
62395   void * jresult ;
62396   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62397   Dali::Vector4 result;
62398
62399   arg1 = (Dali::Toolkit::Control *)jarg1;
62400   {
62401     try {
62402       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
62403     } catch (std::out_of_range& e) {
62404       {
62405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62406       };
62407     } catch (std::exception& e) {
62408       {
62409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62410       };
62411     } catch (...) {
62412       {
62413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62414       };
62415     }
62416   }
62417   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
62418   return jresult;
62419 }
62420
62421
62422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
62423   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62424   Dali::Image arg2 ;
62425   Dali::Image *argp2 ;
62426
62427   arg1 = (Dali::Toolkit::Control *)jarg1;
62428   argp2 = (Dali::Image *)jarg2;
62429   if (!argp2) {
62430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62431     return ;
62432   }
62433   arg2 = *argp2;
62434   {
62435     try {
62436       (arg1)->SetBackgroundImage(arg2);
62437     } catch (std::out_of_range& e) {
62438       {
62439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62440       };
62441     } catch (std::exception& e) {
62442       {
62443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62444       };
62445     } catch (...) {
62446       {
62447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62448       };
62449     }
62450   }
62451 }
62452
62453
62454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
62455   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62456
62457   arg1 = (Dali::Toolkit::Control *)jarg1;
62458   {
62459     try {
62460       (arg1)->ClearBackground();
62461     } catch (std::out_of_range& e) {
62462       {
62463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62464       };
62465     } catch (std::exception& e) {
62466       {
62467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62468       };
62469     } catch (...) {
62470       {
62471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62472       };
62473     }
62474   }
62475 }
62476
62477
62478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
62479   void * jresult ;
62480   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62481   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
62482
62483   arg1 = (Dali::Toolkit::Control *)jarg1;
62484   {
62485     try {
62486       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
62487     } catch (std::out_of_range& e) {
62488       {
62489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62490       };
62491     } catch (std::exception& e) {
62492       {
62493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62494       };
62495     } catch (...) {
62496       {
62497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62498       };
62499     }
62500   }
62501   jresult = (void *)result;
62502   return jresult;
62503 }
62504
62505
62506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
62507   void * jresult ;
62508   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62509   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62510
62511   arg1 = (Dali::Toolkit::Control *)jarg1;
62512   {
62513     try {
62514       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
62515     } catch (std::out_of_range& e) {
62516       {
62517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62518       };
62519     } catch (std::exception& e) {
62520       {
62521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62522       };
62523     } catch (...) {
62524       {
62525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62526       };
62527     }
62528   }
62529   jresult = (void *)result;
62530   return jresult;
62531 }
62532
62533
62534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
62535   void * jresult ;
62536   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62537   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62538
62539   arg1 = (Dali::Toolkit::Control *)jarg1;
62540   {
62541     try {
62542       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
62543     } catch (std::out_of_range& e) {
62544       {
62545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62546       };
62547     } catch (std::exception& e) {
62548       {
62549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62550       };
62551     } catch (...) {
62552       {
62553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62554       };
62555     }
62556   }
62557   jresult = (void *)result;
62558   return jresult;
62559 }
62560
62561
62562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
62563   void * jresult ;
62564   Dali::Toolkit::Internal::Control *arg1 = 0 ;
62565   Dali::Toolkit::Control *result = 0 ;
62566
62567   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62568   if (!arg1) {
62569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
62570     return 0;
62571   }
62572   {
62573     try {
62574       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
62575     } catch (std::out_of_range& e) {
62576       {
62577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62578       };
62579     } catch (std::exception& e) {
62580       {
62581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62582       };
62583     } catch (...) {
62584       {
62585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62586       };
62587     }
62588   }
62589   jresult = (void *)result;
62590   return jresult;
62591 }
62592
62593
62594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
62595   void * jresult ;
62596   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
62597
62598   {
62599     try {
62600       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
62601     } catch (std::out_of_range& e) {
62602       {
62603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62604       };
62605     } catch (std::exception& e) {
62606       {
62607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62608       };
62609     } catch (...) {
62610       {
62611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62612       };
62613     }
62614   }
62615   jresult = (void *)result;
62616   return jresult;
62617 }
62618
62619
62620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
62621   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62622
62623   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62624   {
62625     try {
62626       delete arg1;
62627     } catch (std::out_of_range& e) {
62628       {
62629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62630       };
62631     } catch (std::exception& e) {
62632       {
62633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62634       };
62635     } catch (...) {
62636       {
62637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62638       };
62639     }
62640   }
62641 }
62642
62643
62644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
62645   void * jresult ;
62646   Dali::Toolkit::KeyInputFocusManager result;
62647
62648   {
62649     try {
62650       result = Dali::Toolkit::KeyInputFocusManager::Get();
62651     } catch (std::out_of_range& e) {
62652       {
62653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62654       };
62655     } catch (std::exception& e) {
62656       {
62657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62658       };
62659     } catch (...) {
62660       {
62661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62662       };
62663     }
62664   }
62665   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
62666   return jresult;
62667 }
62668
62669
62670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
62671   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62672   Dali::Toolkit::Control arg2 ;
62673   Dali::Toolkit::Control *argp2 ;
62674
62675   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62676   argp2 = (Dali::Toolkit::Control *)jarg2;
62677   if (!argp2) {
62678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
62679     return ;
62680   }
62681   arg2 = *argp2;
62682   {
62683     try {
62684       (arg1)->SetFocus(arg2);
62685     } catch (std::out_of_range& e) {
62686       {
62687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62688       };
62689     } catch (std::exception& e) {
62690       {
62691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62692       };
62693     } catch (...) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62696       };
62697     }
62698   }
62699 }
62700
62701
62702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
62703   void * jresult ;
62704   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62705   Dali::Toolkit::Control result;
62706
62707   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62708   {
62709     try {
62710       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
62711     } catch (std::out_of_range& e) {
62712       {
62713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62714       };
62715     } catch (std::exception& e) {
62716       {
62717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62718       };
62719     } catch (...) {
62720       {
62721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62722       };
62723     }
62724   }
62725   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62726   return jresult;
62727 }
62728
62729
62730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
62731   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62732   Dali::Toolkit::Control arg2 ;
62733   Dali::Toolkit::Control *argp2 ;
62734
62735   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62736   argp2 = (Dali::Toolkit::Control *)jarg2;
62737   if (!argp2) {
62738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
62739     return ;
62740   }
62741   arg2 = *argp2;
62742   {
62743     try {
62744       (arg1)->RemoveFocus(arg2);
62745     } catch (std::out_of_range& e) {
62746       {
62747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62748       };
62749     } catch (std::exception& e) {
62750       {
62751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62752       };
62753     } catch (...) {
62754       {
62755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62756       };
62757     }
62758   }
62759 }
62760
62761
62762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_IsKeyboardListener(void * jarg1, void * jarg2) {
62763   unsigned int jresult ;
62764   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62765   Dali::Toolkit::Control arg2 ;
62766   Dali::Toolkit::Control *argp2 ;
62767   bool result;
62768
62769   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62770   argp2 = (Dali::Toolkit::Control *)jarg2;
62771   if (!argp2) {
62772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
62773     return 0;
62774   }
62775   arg2 = *argp2;
62776   {
62777     try {
62778       result = (bool)(arg1)->IsKeyboardListener(arg2);
62779     } catch (std::out_of_range& e) {
62780       {
62781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62782       };
62783     } catch (std::exception& e) {
62784       {
62785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62786       };
62787     } catch (...) {
62788       {
62789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62790       };
62791     }
62792   }
62793   jresult = result;
62794   return jresult;
62795 }
62796
62797
62798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
62799   void * jresult ;
62800   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62801   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
62802
62803   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62804   {
62805     try {
62806       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
62807     } catch (std::out_of_range& e) {
62808       {
62809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62810       };
62811     } catch (std::exception& e) {
62812       {
62813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62814       };
62815     } catch (...) {
62816       {
62817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62818       };
62819     }
62820   }
62821   jresult = (void *)result;
62822   return jresult;
62823 }
62824
62825
62826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_UnhandledKeyEventSignal(void * jarg1) {
62827   void * jresult ;
62828   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62829   Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *result = 0 ;
62830
62831   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62832   {
62833     try {
62834       result = (Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *) &(arg1)->UnhandledKeyEventSignal();
62835     } catch (std::out_of_range& e) {
62836       {
62837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62838       };
62839     } catch (std::exception& e) {
62840       {
62841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62842       };
62843     } catch (...) {
62844       {
62845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62846       };
62847     }
62848   }
62849   jresult = (void *)result;
62850   return jresult;
62851 }
62852
62853
62854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
62855   void * jresult ;
62856   Dali::Toolkit::Alignment::Padding *result = 0 ;
62857
62858   {
62859     try {
62860       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
62861     } catch (std::out_of_range& e) {
62862       {
62863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62864       };
62865     } catch (std::exception& e) {
62866       {
62867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62868       };
62869     } catch (...) {
62870       {
62871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62872       };
62873     }
62874   }
62875   jresult = (void *)result;
62876   return jresult;
62877 }
62878
62879
62880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
62881   void * jresult ;
62882   float arg1 ;
62883   float arg2 ;
62884   float arg3 ;
62885   float arg4 ;
62886   Dali::Toolkit::Alignment::Padding *result = 0 ;
62887
62888   arg1 = (float)jarg1;
62889   arg2 = (float)jarg2;
62890   arg3 = (float)jarg3;
62891   arg4 = (float)jarg4;
62892   {
62893     try {
62894       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
62895     } catch (std::out_of_range& e) {
62896       {
62897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62898       };
62899     } catch (std::exception& e) {
62900       {
62901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62902       };
62903     } catch (...) {
62904       {
62905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62906       };
62907     }
62908   }
62909   jresult = (void *)result;
62910   return jresult;
62911 }
62912
62913
62914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
62915   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62916   float arg2 ;
62917
62918   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62919   arg2 = (float)jarg2;
62920   if (arg1) (arg1)->left = arg2;
62921 }
62922
62923
62924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
62925   float jresult ;
62926   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62927   float result;
62928
62929   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62930   result = (float) ((arg1)->left);
62931   jresult = result;
62932   return jresult;
62933 }
62934
62935
62936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
62937   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62938   float arg2 ;
62939
62940   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62941   arg2 = (float)jarg2;
62942   if (arg1) (arg1)->right = arg2;
62943 }
62944
62945
62946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
62947   float jresult ;
62948   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62949   float result;
62950
62951   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62952   result = (float) ((arg1)->right);
62953   jresult = result;
62954   return jresult;
62955 }
62956
62957
62958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
62959   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62960   float arg2 ;
62961
62962   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62963   arg2 = (float)jarg2;
62964   if (arg1) (arg1)->top = arg2;
62965 }
62966
62967
62968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
62969   float jresult ;
62970   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62971   float result;
62972
62973   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62974   result = (float) ((arg1)->top);
62975   jresult = result;
62976   return jresult;
62977 }
62978
62979
62980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
62981   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62982   float arg2 ;
62983
62984   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62985   arg2 = (float)jarg2;
62986   if (arg1) (arg1)->bottom = arg2;
62987 }
62988
62989
62990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
62991   float jresult ;
62992   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62993   float result;
62994
62995   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62996   result = (float) ((arg1)->bottom);
62997   jresult = result;
62998   return jresult;
62999 }
63000
63001
63002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63003   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63004
63005   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63006   {
63007     try {
63008       delete arg1;
63009     } catch (std::out_of_range& e) {
63010       {
63011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63012       };
63013     } catch (std::exception& e) {
63014       {
63015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63016       };
63017     } catch (...) {
63018       {
63019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63020       };
63021     }
63022   }
63023 }
63024
63025
63026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63027   void * jresult ;
63028   Dali::Toolkit::Alignment *result = 0 ;
63029
63030   {
63031     try {
63032       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63033     } catch (std::out_of_range& e) {
63034       {
63035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63036       };
63037     } catch (std::exception& e) {
63038       {
63039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63040       };
63041     } catch (...) {
63042       {
63043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63044       };
63045     }
63046   }
63047   jresult = (void *)result;
63048   return jresult;
63049 }
63050
63051
63052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63053   void * jresult ;
63054   Dali::Toolkit::Alignment::Type arg1 ;
63055   Dali::Toolkit::Alignment::Type arg2 ;
63056   Dali::Toolkit::Alignment result;
63057
63058   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63059   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63060   {
63061     try {
63062       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63063     } catch (std::out_of_range& e) {
63064       {
63065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63066       };
63067     } catch (std::exception& e) {
63068       {
63069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63070       };
63071     } catch (...) {
63072       {
63073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63074       };
63075     }
63076   }
63077   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63078   return jresult;
63079 }
63080
63081
63082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63083   void * jresult ;
63084   Dali::Toolkit::Alignment::Type arg1 ;
63085   Dali::Toolkit::Alignment result;
63086
63087   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63088   {
63089     try {
63090       result = Dali::Toolkit::Alignment::New(arg1);
63091     } catch (std::out_of_range& e) {
63092       {
63093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63094       };
63095     } catch (std::exception& e) {
63096       {
63097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63098       };
63099     } catch (...) {
63100       {
63101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63102       };
63103     }
63104   }
63105   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63106   return jresult;
63107 }
63108
63109
63110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63111   void * jresult ;
63112   Dali::Toolkit::Alignment result;
63113
63114   {
63115     try {
63116       result = Dali::Toolkit::Alignment::New();
63117     } catch (std::out_of_range& e) {
63118       {
63119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63120       };
63121     } catch (std::exception& e) {
63122       {
63123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63124       };
63125     } catch (...) {
63126       {
63127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63128       };
63129     }
63130   }
63131   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63132   return jresult;
63133 }
63134
63135
63136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63137   void * jresult ;
63138   Dali::Toolkit::Alignment *arg1 = 0 ;
63139   Dali::Toolkit::Alignment *result = 0 ;
63140
63141   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63142   if (!arg1) {
63143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63144     return 0;
63145   }
63146   {
63147     try {
63148       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63149     } catch (std::out_of_range& e) {
63150       {
63151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63152       };
63153     } catch (std::exception& e) {
63154       {
63155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63156       };
63157     } catch (...) {
63158       {
63159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63160       };
63161     }
63162   }
63163   jresult = (void *)result;
63164   return jresult;
63165 }
63166
63167
63168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63169   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63170
63171   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63172   {
63173     try {
63174       delete arg1;
63175     } catch (std::out_of_range& e) {
63176       {
63177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63178       };
63179     } catch (std::exception& e) {
63180       {
63181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63182       };
63183     } catch (...) {
63184       {
63185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63186       };
63187     }
63188   }
63189 }
63190
63191
63192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63193   void * jresult ;
63194   Dali::BaseHandle arg1 ;
63195   Dali::BaseHandle *argp1 ;
63196   Dali::Toolkit::Alignment result;
63197
63198   argp1 = (Dali::BaseHandle *)jarg1;
63199   if (!argp1) {
63200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63201     return 0;
63202   }
63203   arg1 = *argp1;
63204   {
63205     try {
63206       result = Dali::Toolkit::Alignment::DownCast(arg1);
63207     } catch (std::out_of_range& e) {
63208       {
63209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63210       };
63211     } catch (std::exception& e) {
63212       {
63213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63214       };
63215     } catch (...) {
63216       {
63217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63218       };
63219     }
63220   }
63221   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63222   return jresult;
63223 }
63224
63225
63226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63227   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63228   Dali::Toolkit::Alignment::Type arg2 ;
63229
63230   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63231   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63232   {
63233     try {
63234       (arg1)->SetAlignmentType(arg2);
63235     } catch (std::out_of_range& e) {
63236       {
63237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63238       };
63239     } catch (std::exception& e) {
63240       {
63241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63242       };
63243     } catch (...) {
63244       {
63245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63246       };
63247     }
63248   }
63249 }
63250
63251
63252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63253   int jresult ;
63254   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63255   Dali::Toolkit::Alignment::Type result;
63256
63257   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63258   {
63259     try {
63260       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63261     } catch (std::out_of_range& e) {
63262       {
63263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63264       };
63265     } catch (std::exception& e) {
63266       {
63267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63268       };
63269     } catch (...) {
63270       {
63271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63272       };
63273     }
63274   }
63275   jresult = (int)result;
63276   return jresult;
63277 }
63278
63279
63280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63281   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63282   Dali::Toolkit::Alignment::Scaling arg2 ;
63283
63284   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63285   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63286   {
63287     try {
63288       (arg1)->SetScaling(arg2);
63289     } catch (std::out_of_range& e) {
63290       {
63291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63292       };
63293     } catch (std::exception& e) {
63294       {
63295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63296       };
63297     } catch (...) {
63298       {
63299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63300       };
63301     }
63302   }
63303 }
63304
63305
63306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63307   int jresult ;
63308   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63309   Dali::Toolkit::Alignment::Scaling result;
63310
63311   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63312   {
63313     try {
63314       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63315     } catch (std::out_of_range& e) {
63316       {
63317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63318       };
63319     } catch (std::exception& e) {
63320       {
63321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63322       };
63323     } catch (...) {
63324       {
63325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63326       };
63327     }
63328   }
63329   jresult = (int)result;
63330   return jresult;
63331 }
63332
63333
63334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63335   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63336   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63337
63338   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63339   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63340   if (!arg2) {
63341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63342     return ;
63343   }
63344   {
63345     try {
63346       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63347     } catch (std::out_of_range& e) {
63348       {
63349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63350       };
63351     } catch (std::exception& e) {
63352       {
63353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63354       };
63355     } catch (...) {
63356       {
63357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63358       };
63359     }
63360   }
63361 }
63362
63363
63364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63365   void * jresult ;
63366   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63367   Dali::Toolkit::Alignment::Padding *result = 0 ;
63368
63369   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63370   {
63371     try {
63372       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63373     } catch (std::out_of_range& e) {
63374       {
63375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63376       };
63377     } catch (std::exception& e) {
63378       {
63379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63380       };
63381     } catch (...) {
63382       {
63383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63384       };
63385     }
63386   }
63387   jresult = (void *)result;
63388   return jresult;
63389 }
63390
63391
63392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63393   void * jresult ;
63394   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63395   Dali::Toolkit::Alignment *arg2 = 0 ;
63396   Dali::Toolkit::Alignment *result = 0 ;
63397
63398   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63399   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63400   if (!arg2) {
63401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63402     return 0;
63403   }
63404   {
63405     try {
63406       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
63407     } catch (std::out_of_range& e) {
63408       {
63409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63410       };
63411     } catch (std::exception& e) {
63412       {
63413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63414       };
63415     } catch (...) {
63416       {
63417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63418       };
63419     }
63420   }
63421   jresult = (void *)result;
63422   return jresult;
63423 }
63424
63425
63426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
63427   int jresult ;
63428   int result;
63429
63430   result = (int)Dali::Toolkit::Button::Property::DISABLED;
63431   jresult = (int)result;
63432   return jresult;
63433 }
63434
63435
63436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
63437   int jresult ;
63438   int result;
63439
63440   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
63441   jresult = (int)result;
63442   return jresult;
63443 }
63444
63445
63446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
63447   int jresult ;
63448   int result;
63449
63450   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
63451   jresult = (int)result;
63452   return jresult;
63453 }
63454
63455
63456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
63457   int jresult ;
63458   int result;
63459
63460   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
63461   jresult = (int)result;
63462   return jresult;
63463 }
63464
63465
63466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
63467   int jresult ;
63468   int result;
63469
63470   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
63471   jresult = (int)result;
63472   return jresult;
63473 }
63474
63475
63476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
63477   int jresult ;
63478   int result;
63479
63480   result = (int)Dali::Toolkit::Button::Property::SELECTED;
63481   jresult = (int)result;
63482   return jresult;
63483 }
63484
63485
63486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
63487   int jresult ;
63488   int result;
63489
63490   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
63491   jresult = (int)result;
63492   return jresult;
63493 }
63494
63495
63496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
63497   int jresult ;
63498   int result;
63499
63500   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
63501   jresult = (int)result;
63502   return jresult;
63503 }
63504
63505
63506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
63507   int jresult ;
63508   int result;
63509
63510   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
63511   jresult = (int)result;
63512   return jresult;
63513 }
63514
63515
63516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
63517   int jresult ;
63518   int result;
63519
63520   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
63521   jresult = (int)result;
63522   return jresult;
63523 }
63524
63525
63526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
63527   int jresult ;
63528   int result;
63529
63530   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
63531   jresult = (int)result;
63532   return jresult;
63533 }
63534
63535
63536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
63537   int jresult ;
63538   int result;
63539
63540   result = (int)Dali::Toolkit::Button::Property::LABEL;
63541   jresult = (int)result;
63542   return jresult;
63543 }
63544
63545
63546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
63547   int jresult ;
63548   int result;
63549
63550   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
63551   jresult = (int)result;
63552   return jresult;
63553 }
63554
63555
63556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
63557   void * jresult ;
63558   Dali::Toolkit::Button::Property *result = 0 ;
63559
63560   {
63561     try {
63562       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
63563     } catch (std::out_of_range& e) {
63564       {
63565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63566       };
63567     } catch (std::exception& e) {
63568       {
63569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63570       };
63571     } catch (...) {
63572       {
63573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63574       };
63575     }
63576   }
63577   jresult = (void *)result;
63578   return jresult;
63579 }
63580
63581
63582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
63583   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
63584
63585   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
63586   {
63587     try {
63588       delete arg1;
63589     } catch (std::out_of_range& e) {
63590       {
63591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63592       };
63593     } catch (std::exception& e) {
63594       {
63595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63596       };
63597     } catch (...) {
63598       {
63599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63600       };
63601     }
63602   }
63603 }
63604
63605
63606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
63607   void * jresult ;
63608   Dali::Toolkit::Button *result = 0 ;
63609
63610   {
63611     try {
63612       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
63613     } catch (std::out_of_range& e) {
63614       {
63615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63616       };
63617     } catch (std::exception& e) {
63618       {
63619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63620       };
63621     } catch (...) {
63622       {
63623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63624       };
63625     }
63626   }
63627   jresult = (void *)result;
63628   return jresult;
63629 }
63630
63631
63632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
63633   void * jresult ;
63634   Dali::Toolkit::Button *arg1 = 0 ;
63635   Dali::Toolkit::Button *result = 0 ;
63636
63637   arg1 = (Dali::Toolkit::Button *)jarg1;
63638   if (!arg1) {
63639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
63640     return 0;
63641   }
63642   {
63643     try {
63644       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
63645     } catch (std::out_of_range& e) {
63646       {
63647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63648       };
63649     } catch (std::exception& e) {
63650       {
63651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63652       };
63653     } catch (...) {
63654       {
63655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63656       };
63657     }
63658   }
63659   jresult = (void *)result;
63660   return jresult;
63661 }
63662
63663
63664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
63665   void * jresult ;
63666   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63667   Dali::Toolkit::Button *arg2 = 0 ;
63668   Dali::Toolkit::Button *result = 0 ;
63669
63670   arg1 = (Dali::Toolkit::Button *)jarg1;
63671   arg2 = (Dali::Toolkit::Button *)jarg2;
63672   if (!arg2) {
63673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
63674     return 0;
63675   }
63676   {
63677     try {
63678       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
63679     } catch (std::out_of_range& e) {
63680       {
63681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63682       };
63683     } catch (std::exception& e) {
63684       {
63685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63686       };
63687     } catch (...) {
63688       {
63689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63690       };
63691     }
63692   }
63693   jresult = (void *)result;
63694   return jresult;
63695 }
63696
63697
63698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
63699   void * jresult ;
63700   Dali::BaseHandle arg1 ;
63701   Dali::BaseHandle *argp1 ;
63702   Dali::Toolkit::Button result;
63703
63704   argp1 = (Dali::BaseHandle *)jarg1;
63705   if (!argp1) {
63706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63707     return 0;
63708   }
63709   arg1 = *argp1;
63710   {
63711     try {
63712       result = Dali::Toolkit::Button::DownCast(arg1);
63713     } catch (std::out_of_range& e) {
63714       {
63715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63716       };
63717     } catch (std::exception& e) {
63718       {
63719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63720       };
63721     } catch (...) {
63722       {
63723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63724       };
63725     }
63726   }
63727   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
63728   return jresult;
63729 }
63730
63731
63732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
63733   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63734
63735   arg1 = (Dali::Toolkit::Button *)jarg1;
63736   {
63737     try {
63738       delete arg1;
63739     } catch (std::out_of_range& e) {
63740       {
63741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63742       };
63743     } catch (std::exception& e) {
63744       {
63745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63746       };
63747     } catch (...) {
63748       {
63749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63750       };
63751     }
63752   }
63753 }
63754
63755
63756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
63757   unsigned int jresult ;
63758   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63759   bool result;
63760
63761   arg1 = (Dali::Toolkit::Button *)jarg1;
63762   {
63763     try {
63764       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
63765     } catch (std::out_of_range& e) {
63766       {
63767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63768       };
63769     } catch (std::exception& e) {
63770       {
63771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63772       };
63773     } catch (...) {
63774       {
63775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63776       };
63777     }
63778   }
63779   jresult = result;
63780   return jresult;
63781 }
63782
63783
63784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
63785   unsigned int jresult ;
63786   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63787   bool result;
63788
63789   arg1 = (Dali::Toolkit::Button *)jarg1;
63790   {
63791     try {
63792       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
63793     } catch (std::out_of_range& e) {
63794       {
63795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63796       };
63797     } catch (std::exception& e) {
63798       {
63799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63800       };
63801     } catch (...) {
63802       {
63803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63804       };
63805     }
63806   }
63807   jresult = result;
63808   return jresult;
63809 }
63810
63811
63812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
63813   float jresult ;
63814   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63815   float result;
63816
63817   arg1 = (Dali::Toolkit::Button *)jarg1;
63818   {
63819     try {
63820       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
63821     } catch (std::out_of_range& e) {
63822       {
63823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63824       };
63825     } catch (std::exception& e) {
63826       {
63827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63828       };
63829     } catch (...) {
63830       {
63831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63832       };
63833     }
63834   }
63835   jresult = result;
63836   return jresult;
63837 }
63838
63839
63840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
63841   float jresult ;
63842   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63843   float result;
63844
63845   arg1 = (Dali::Toolkit::Button *)jarg1;
63846   {
63847     try {
63848       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
63849     } catch (std::out_of_range& e) {
63850       {
63851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63852       };
63853     } catch (std::exception& e) {
63854       {
63855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63856       };
63857     } catch (...) {
63858       {
63859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63860       };
63861     }
63862   }
63863   jresult = result;
63864   return jresult;
63865 }
63866
63867
63868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
63869   unsigned int jresult ;
63870   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63871   bool result;
63872
63873   arg1 = (Dali::Toolkit::Button *)jarg1;
63874   {
63875     try {
63876       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
63877     } catch (std::out_of_range& e) {
63878       {
63879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63880       };
63881     } catch (std::exception& e) {
63882       {
63883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63884       };
63885     } catch (...) {
63886       {
63887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63888       };
63889     }
63890   }
63891   jresult = result;
63892   return jresult;
63893 }
63894
63895
63896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
63897   unsigned int jresult ;
63898   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63899   bool result;
63900
63901   arg1 = (Dali::Toolkit::Button *)jarg1;
63902   {
63903     try {
63904       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
63905     } catch (std::out_of_range& e) {
63906       {
63907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63908       };
63909     } catch (std::exception& e) {
63910       {
63911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63912       };
63913     } catch (...) {
63914       {
63915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63916       };
63917     }
63918   }
63919   jresult = result;
63920   return jresult;
63921 }
63922
63923
63924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
63925   float jresult ;
63926   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63927   float result;
63928
63929   arg1 = (Dali::Toolkit::Button *)jarg1;
63930   {
63931     try {
63932       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
63933     } catch (std::out_of_range& e) {
63934       {
63935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63936       };
63937     } catch (std::exception& e) {
63938       {
63939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63940       };
63941     } catch (...) {
63942       {
63943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63944       };
63945     }
63946   }
63947   jresult = result;
63948   return jresult;
63949 }
63950
63951
63952 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
63953   char * jresult ;
63954   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63955   std::string result;
63956
63957   arg1 = (Dali::Toolkit::Button *)jarg1;
63958   {
63959     try {
63960       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
63961     } catch (std::out_of_range& e) {
63962       {
63963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63964       };
63965     } catch (std::exception& e) {
63966       {
63967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63968       };
63969     } catch (...) {
63970       {
63971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63972       };
63973     }
63974   }
63975   jresult = SWIG_csharp_string_callback((&result)->c_str());
63976   return jresult;
63977 }
63978
63979
63980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
63981   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63982   Dali::Actor arg2 ;
63983   Dali::Actor *argp2 ;
63984
63985   arg1 = (Dali::Toolkit::Button *)jarg1;
63986   argp2 = (Dali::Actor *)jarg2;
63987   if (!argp2) {
63988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63989     return ;
63990   }
63991   arg2 = *argp2;
63992   {
63993     try {
63994       (arg1)->SetLabel(arg2);
63995     } catch (std::out_of_range& e) {
63996       {
63997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63998       };
63999     } catch (std::exception& e) {
64000       {
64001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64002       };
64003     } catch (...) {
64004       {
64005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64006       };
64007     }
64008   }
64009 }
64010
64011
64012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64013   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64014   Dali::Image arg2 ;
64015   Dali::Image *argp2 ;
64016
64017   arg1 = (Dali::Toolkit::Button *)jarg1;
64018   argp2 = (Dali::Image *)jarg2;
64019   if (!argp2) {
64020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64021     return ;
64022   }
64023   arg2 = *argp2;
64024   {
64025     try {
64026       (arg1)->SetButtonImage(arg2);
64027     } catch (std::out_of_range& e) {
64028       {
64029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64030       };
64031     } catch (std::exception& e) {
64032       {
64033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64034       };
64035     } catch (...) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64038       };
64039     }
64040   }
64041 }
64042
64043
64044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64045   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64046   Dali::Image arg2 ;
64047   Dali::Image *argp2 ;
64048
64049   arg1 = (Dali::Toolkit::Button *)jarg1;
64050   argp2 = (Dali::Image *)jarg2;
64051   if (!argp2) {
64052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64053     return ;
64054   }
64055   arg2 = *argp2;
64056   {
64057     try {
64058       (arg1)->SetSelectedImage(arg2);
64059     } catch (std::out_of_range& e) {
64060       {
64061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64062       };
64063     } catch (std::exception& e) {
64064       {
64065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64066       };
64067     } catch (...) {
64068       {
64069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64070       };
64071     }
64072   }
64073 }
64074
64075
64076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64077   void * jresult ;
64078   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64079   Dali::Actor result;
64080
64081   arg1 = (Dali::Toolkit::Button *)jarg1;
64082   {
64083     try {
64084       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64085     } catch (std::out_of_range& e) {
64086       {
64087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64088       };
64089     } catch (std::exception& e) {
64090       {
64091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64092       };
64093     } catch (...) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64096       };
64097     }
64098   }
64099   jresult = new Dali::Actor((const Dali::Actor &)result);
64100   return jresult;
64101 }
64102
64103
64104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64105   void * jresult ;
64106   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64107   Dali::Actor result;
64108
64109   arg1 = (Dali::Toolkit::Button *)jarg1;
64110   {
64111     try {
64112       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64113     } catch (std::out_of_range& e) {
64114       {
64115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64116       };
64117     } catch (std::exception& e) {
64118       {
64119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64120       };
64121     } catch (...) {
64122       {
64123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64124       };
64125     }
64126   }
64127   jresult = new Dali::Actor((const Dali::Actor &)result);
64128   return jresult;
64129 }
64130
64131
64132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64133   void * jresult ;
64134   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64135   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64136
64137   arg1 = (Dali::Toolkit::Button *)jarg1;
64138   {
64139     try {
64140       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64141     } catch (std::out_of_range& e) {
64142       {
64143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64144       };
64145     } catch (std::exception& e) {
64146       {
64147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64148       };
64149     } catch (...) {
64150       {
64151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64152       };
64153     }
64154   }
64155   jresult = (void *)result;
64156   return jresult;
64157 }
64158
64159
64160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64161   void * jresult ;
64162   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64163   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64164
64165   arg1 = (Dali::Toolkit::Button *)jarg1;
64166   {
64167     try {
64168       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
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_Button_ClickedSignal(void * jarg1) {
64189   void * jresult ;
64190   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64191   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64192
64193   arg1 = (Dali::Toolkit::Button *)jarg1;
64194   {
64195     try {
64196       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64197     } catch (std::out_of_range& e) {
64198       {
64199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64200       };
64201     } catch (std::exception& e) {
64202       {
64203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64204       };
64205     } catch (...) {
64206       {
64207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64208       };
64209     }
64210   }
64211   jresult = (void *)result;
64212   return jresult;
64213 }
64214
64215
64216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64217   void * jresult ;
64218   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64219   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64220
64221   arg1 = (Dali::Toolkit::Button *)jarg1;
64222   {
64223     try {
64224       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64225     } catch (std::out_of_range& e) {
64226       {
64227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64228       };
64229     } catch (std::exception& e) {
64230       {
64231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64232       };
64233     } catch (...) {
64234       {
64235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64236       };
64237     }
64238   }
64239   jresult = (void *)result;
64240   return jresult;
64241 }
64242
64243
64244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64245   void * jresult ;
64246   Dali::Toolkit::CheckBoxButton *result = 0 ;
64247
64248   {
64249     try {
64250       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
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_new_CheckBoxButton__SWIG_1(void * jarg1) {
64271   void * jresult ;
64272   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64273   Dali::Toolkit::CheckBoxButton *result = 0 ;
64274
64275   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64276   if (!arg1) {
64277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64278     return 0;
64279   }
64280   {
64281     try {
64282       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
64283     } catch (std::out_of_range& e) {
64284       {
64285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64286       };
64287     } catch (std::exception& e) {
64288       {
64289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64290       };
64291     } catch (...) {
64292       {
64293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64294       };
64295     }
64296   }
64297   jresult = (void *)result;
64298   return jresult;
64299 }
64300
64301
64302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64303   void * jresult ;
64304   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64305   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64306   Dali::Toolkit::CheckBoxButton *result = 0 ;
64307
64308   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64309   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64310   if (!arg2) {
64311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64312     return 0;
64313   }
64314   {
64315     try {
64316       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64317     } catch (std::out_of_range& e) {
64318       {
64319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64320       };
64321     } catch (std::exception& e) {
64322       {
64323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64324       };
64325     } catch (...) {
64326       {
64327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64328       };
64329     }
64330   }
64331   jresult = (void *)result;
64332   return jresult;
64333 }
64334
64335
64336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64337   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64338
64339   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64340   {
64341     try {
64342       delete arg1;
64343     } catch (std::out_of_range& e) {
64344       {
64345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64346       };
64347     } catch (std::exception& e) {
64348       {
64349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64350       };
64351     } catch (...) {
64352       {
64353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64354       };
64355     }
64356   }
64357 }
64358
64359
64360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64361   void * jresult ;
64362   Dali::Toolkit::CheckBoxButton result;
64363
64364   {
64365     try {
64366       result = Dali::Toolkit::CheckBoxButton::New();
64367     } catch (std::out_of_range& e) {
64368       {
64369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64370       };
64371     } catch (std::exception& e) {
64372       {
64373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64374       };
64375     } catch (...) {
64376       {
64377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64378       };
64379     }
64380   }
64381   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64382   return jresult;
64383 }
64384
64385
64386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64387   void * jresult ;
64388   Dali::BaseHandle arg1 ;
64389   Dali::BaseHandle *argp1 ;
64390   Dali::Toolkit::CheckBoxButton result;
64391
64392   argp1 = (Dali::BaseHandle *)jarg1;
64393   if (!argp1) {
64394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64395     return 0;
64396   }
64397   arg1 = *argp1;
64398   {
64399     try {
64400       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64401     } catch (std::out_of_range& e) {
64402       {
64403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64404       };
64405     } catch (std::exception& e) {
64406       {
64407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64408       };
64409     } catch (...) {
64410       {
64411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64412       };
64413     }
64414   }
64415   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64416   return jresult;
64417 }
64418
64419
64420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
64421   int jresult ;
64422   int result;
64423
64424   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
64425   jresult = (int)result;
64426   return jresult;
64427 }
64428
64429
64430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
64431   int jresult ;
64432   int result;
64433
64434   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
64435   jresult = (int)result;
64436   return jresult;
64437 }
64438
64439
64440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
64441   int jresult ;
64442   int result;
64443
64444   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
64445   jresult = (int)result;
64446   return jresult;
64447 }
64448
64449
64450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
64451   int jresult ;
64452   int result;
64453
64454   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
64455   jresult = (int)result;
64456   return jresult;
64457 }
64458
64459
64460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
64461   int jresult ;
64462   int result;
64463
64464   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
64465   jresult = (int)result;
64466   return jresult;
64467 }
64468
64469
64470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
64471   void * jresult ;
64472   Dali::Toolkit::PushButton::Property *result = 0 ;
64473
64474   {
64475     try {
64476       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
64477     } catch (std::out_of_range& e) {
64478       {
64479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64480       };
64481     } catch (std::exception& e) {
64482       {
64483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64484       };
64485     } catch (...) {
64486       {
64487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64488       };
64489     }
64490   }
64491   jresult = (void *)result;
64492   return jresult;
64493 }
64494
64495
64496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
64497   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
64498
64499   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
64500   {
64501     try {
64502       delete arg1;
64503     } catch (std::out_of_range& e) {
64504       {
64505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64506       };
64507     } catch (std::exception& e) {
64508       {
64509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64510       };
64511     } catch (...) {
64512       {
64513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64514       };
64515     }
64516   }
64517 }
64518
64519
64520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
64521   void * jresult ;
64522   Dali::Toolkit::PushButton *result = 0 ;
64523
64524   {
64525     try {
64526       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
64527     } catch (std::out_of_range& e) {
64528       {
64529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64530       };
64531     } catch (std::exception& e) {
64532       {
64533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64534       };
64535     } catch (...) {
64536       {
64537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64538       };
64539     }
64540   }
64541   jresult = (void *)result;
64542   return jresult;
64543 }
64544
64545
64546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
64547   void * jresult ;
64548   Dali::Toolkit::PushButton *arg1 = 0 ;
64549   Dali::Toolkit::PushButton *result = 0 ;
64550
64551   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64552   if (!arg1) {
64553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64554     return 0;
64555   }
64556   {
64557     try {
64558       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
64559     } catch (std::out_of_range& e) {
64560       {
64561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64562       };
64563     } catch (std::exception& e) {
64564       {
64565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64566       };
64567     } catch (...) {
64568       {
64569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64570       };
64571     }
64572   }
64573   jresult = (void *)result;
64574   return jresult;
64575 }
64576
64577
64578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
64579   void * jresult ;
64580   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64581   Dali::Toolkit::PushButton *arg2 = 0 ;
64582   Dali::Toolkit::PushButton *result = 0 ;
64583
64584   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64585   arg2 = (Dali::Toolkit::PushButton *)jarg2;
64586   if (!arg2) {
64587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64588     return 0;
64589   }
64590   {
64591     try {
64592       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
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 void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
64613   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64614
64615   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64616   {
64617     try {
64618       delete arg1;
64619     } catch (std::out_of_range& e) {
64620       {
64621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64622       };
64623     } catch (std::exception& e) {
64624       {
64625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64626       };
64627     } catch (...) {
64628       {
64629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64630       };
64631     }
64632   }
64633 }
64634
64635
64636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
64637   void * jresult ;
64638   Dali::Toolkit::PushButton result;
64639
64640   {
64641     try {
64642       result = Dali::Toolkit::PushButton::New();
64643     } catch (std::out_of_range& e) {
64644       {
64645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64646       };
64647     } catch (std::exception& e) {
64648       {
64649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64650       };
64651     } catch (...) {
64652       {
64653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64654       };
64655     }
64656   }
64657   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
64658   return jresult;
64659 }
64660
64661
64662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
64663   void * jresult ;
64664   Dali::BaseHandle arg1 ;
64665   Dali::BaseHandle *argp1 ;
64666   Dali::Toolkit::PushButton result;
64667
64668   argp1 = (Dali::BaseHandle *)jarg1;
64669   if (!argp1) {
64670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64671     return 0;
64672   }
64673   arg1 = *argp1;
64674   {
64675     try {
64676       result = Dali::Toolkit::PushButton::DownCast(arg1);
64677     } catch (std::out_of_range& e) {
64678       {
64679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64680       };
64681     } catch (std::exception& e) {
64682       {
64683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64684       };
64685     } catch (...) {
64686       {
64687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64688       };
64689     }
64690   }
64691   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
64692   return jresult;
64693 }
64694
64695
64696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
64697   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64698   Dali::Image arg2 ;
64699   Dali::Image *argp2 ;
64700
64701   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64702   argp2 = (Dali::Image *)jarg2;
64703   if (!argp2) {
64704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64705     return ;
64706   }
64707   arg2 = *argp2;
64708   {
64709     try {
64710       (arg1)->SetButtonImage(arg2);
64711     } catch (std::out_of_range& e) {
64712       {
64713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64714       };
64715     } catch (std::exception& e) {
64716       {
64717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64718       };
64719     } catch (...) {
64720       {
64721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64722       };
64723     }
64724   }
64725 }
64726
64727
64728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
64729   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64730   Dali::Actor arg2 ;
64731   Dali::Actor *argp2 ;
64732
64733   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64734   argp2 = (Dali::Actor *)jarg2;
64735   if (!argp2) {
64736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64737     return ;
64738   }
64739   arg2 = *argp2;
64740   {
64741     try {
64742       (arg1)->SetButtonImage(arg2);
64743     } catch (std::out_of_range& e) {
64744       {
64745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64746       };
64747     } catch (std::exception& e) {
64748       {
64749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64750       };
64751     } catch (...) {
64752       {
64753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64754       };
64755     }
64756   }
64757 }
64758
64759
64760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
64761   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64762   Dali::Actor arg2 ;
64763   Dali::Actor *argp2 ;
64764
64765   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64766   argp2 = (Dali::Actor *)jarg2;
64767   if (!argp2) {
64768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64769     return ;
64770   }
64771   arg2 = *argp2;
64772   {
64773     try {
64774       (arg1)->SetBackgroundImage(arg2);
64775     } catch (std::out_of_range& e) {
64776       {
64777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64778       };
64779     } catch (std::exception& e) {
64780       {
64781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64782       };
64783     } catch (...) {
64784       {
64785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64786       };
64787     }
64788   }
64789 }
64790
64791
64792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
64793   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64794   Dali::Image arg2 ;
64795   Dali::Image *argp2 ;
64796
64797   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64798   argp2 = (Dali::Image *)jarg2;
64799   if (!argp2) {
64800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64801     return ;
64802   }
64803   arg2 = *argp2;
64804   {
64805     try {
64806       (arg1)->SetSelectedImage(arg2);
64807     } catch (std::out_of_range& e) {
64808       {
64809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64810       };
64811     } catch (std::exception& e) {
64812       {
64813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64814       };
64815     } catch (...) {
64816       {
64817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64818       };
64819     }
64820   }
64821 }
64822
64823
64824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
64825   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64826   Dali::Actor arg2 ;
64827   Dali::Actor *argp2 ;
64828
64829   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64830   argp2 = (Dali::Actor *)jarg2;
64831   if (!argp2) {
64832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64833     return ;
64834   }
64835   arg2 = *argp2;
64836   {
64837     try {
64838       (arg1)->SetSelectedImage(arg2);
64839     } catch (std::out_of_range& e) {
64840       {
64841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64842       };
64843     } catch (std::exception& e) {
64844       {
64845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64846       };
64847     } catch (...) {
64848       {
64849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64850       };
64851     }
64852   }
64853 }
64854
64855
64856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
64857   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64858   Dali::Actor arg2 ;
64859   Dali::Actor *argp2 ;
64860
64861   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64862   argp2 = (Dali::Actor *)jarg2;
64863   if (!argp2) {
64864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64865     return ;
64866   }
64867   arg2 = *argp2;
64868   {
64869     try {
64870       (arg1)->SetSelectedBackgroundImage(arg2);
64871     } catch (std::out_of_range& e) {
64872       {
64873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64874       };
64875     } catch (std::exception& e) {
64876       {
64877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64878       };
64879     } catch (...) {
64880       {
64881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64882       };
64883     }
64884   }
64885 }
64886
64887
64888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
64889   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64890   Dali::Actor arg2 ;
64891   Dali::Actor *argp2 ;
64892
64893   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64894   argp2 = (Dali::Actor *)jarg2;
64895   if (!argp2) {
64896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64897     return ;
64898   }
64899   arg2 = *argp2;
64900   {
64901     try {
64902       (arg1)->SetDisabledBackgroundImage(arg2);
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_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
64921   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64922   Dali::Actor arg2 ;
64923   Dali::Actor *argp2 ;
64924
64925   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64926   argp2 = (Dali::Actor *)jarg2;
64927   if (!argp2) {
64928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64929     return ;
64930   }
64931   arg2 = *argp2;
64932   {
64933     try {
64934       (arg1)->SetDisabledImage(arg2);
64935     } catch (std::out_of_range& e) {
64936       {
64937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64938       };
64939     } catch (std::exception& e) {
64940       {
64941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64942       };
64943     } catch (...) {
64944       {
64945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64946       };
64947     }
64948   }
64949 }
64950
64951
64952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
64953   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64954   Dali::Actor arg2 ;
64955   Dali::Actor *argp2 ;
64956
64957   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64958   argp2 = (Dali::Actor *)jarg2;
64959   if (!argp2) {
64960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64961     return ;
64962   }
64963   arg2 = *argp2;
64964   {
64965     try {
64966       (arg1)->SetDisabledSelectedImage(arg2);
64967     } catch (std::out_of_range& e) {
64968       {
64969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64970       };
64971     } catch (std::exception& e) {
64972       {
64973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64974       };
64975     } catch (...) {
64976       {
64977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64978       };
64979     }
64980   }
64981 }
64982
64983
64984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
64985   void * jresult ;
64986   Dali::Toolkit::RadioButton *result = 0 ;
64987
64988   {
64989     try {
64990       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
64991     } catch (std::out_of_range& e) {
64992       {
64993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64994       };
64995     } catch (std::exception& e) {
64996       {
64997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64998       };
64999     } catch (...) {
65000       {
65001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65002       };
65003     }
65004   }
65005   jresult = (void *)result;
65006   return jresult;
65007 }
65008
65009
65010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65011   void * jresult ;
65012   Dali::Toolkit::RadioButton *arg1 = 0 ;
65013   Dali::Toolkit::RadioButton *result = 0 ;
65014
65015   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65016   if (!arg1) {
65017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65018     return 0;
65019   }
65020   {
65021     try {
65022       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65023     } catch (std::out_of_range& e) {
65024       {
65025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65026       };
65027     } catch (std::exception& e) {
65028       {
65029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65030       };
65031     } catch (...) {
65032       {
65033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65034       };
65035     }
65036   }
65037   jresult = (void *)result;
65038   return jresult;
65039 }
65040
65041
65042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65043   void * jresult ;
65044   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65045   Dali::Toolkit::RadioButton *arg2 = 0 ;
65046   Dali::Toolkit::RadioButton *result = 0 ;
65047
65048   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65049   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65050   if (!arg2) {
65051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65052     return 0;
65053   }
65054   {
65055     try {
65056       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65057     } catch (std::out_of_range& e) {
65058       {
65059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65060       };
65061     } catch (std::exception& e) {
65062       {
65063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65064       };
65065     } catch (...) {
65066       {
65067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65068       };
65069     }
65070   }
65071   jresult = (void *)result;
65072   return jresult;
65073 }
65074
65075
65076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65077   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65078
65079   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65080   {
65081     try {
65082       delete arg1;
65083     } catch (std::out_of_range& e) {
65084       {
65085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65086       };
65087     } catch (std::exception& e) {
65088       {
65089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65090       };
65091     } catch (...) {
65092       {
65093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65094       };
65095     }
65096   }
65097 }
65098
65099
65100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65101   void * jresult ;
65102   Dali::Toolkit::RadioButton result;
65103
65104   {
65105     try {
65106       result = Dali::Toolkit::RadioButton::New();
65107     } catch (std::out_of_range& e) {
65108       {
65109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65110       };
65111     } catch (std::exception& e) {
65112       {
65113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65114       };
65115     } catch (...) {
65116       {
65117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65118       };
65119     }
65120   }
65121   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65122   return jresult;
65123 }
65124
65125
65126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65127   void * jresult ;
65128   std::string *arg1 = 0 ;
65129   Dali::Toolkit::RadioButton result;
65130
65131   if (!jarg1) {
65132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65133     return 0;
65134   }
65135   std::string arg1_str(jarg1);
65136   arg1 = &arg1_str;
65137   {
65138     try {
65139       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65140     } catch (std::out_of_range& e) {
65141       {
65142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65143       };
65144     } catch (std::exception& e) {
65145       {
65146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65147       };
65148     } catch (...) {
65149       {
65150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65151       };
65152     }
65153   }
65154   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65155
65156   //argout typemap for const std::string&
65157
65158   return jresult;
65159 }
65160
65161
65162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65163   void * jresult ;
65164   Dali::BaseHandle arg1 ;
65165   Dali::BaseHandle *argp1 ;
65166   Dali::Toolkit::RadioButton result;
65167
65168   argp1 = (Dali::BaseHandle *)jarg1;
65169   if (!argp1) {
65170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65171     return 0;
65172   }
65173   arg1 = *argp1;
65174   {
65175     try {
65176       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65177     } catch (std::out_of_range& e) {
65178       {
65179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65180       };
65181     } catch (std::exception& e) {
65182       {
65183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65184       };
65185     } catch (...) {
65186       {
65187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65188       };
65189     }
65190   }
65191   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65192   return jresult;
65193 }
65194
65195
65196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65197   int jresult ;
65198   int result;
65199
65200   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65201   jresult = (int)result;
65202   return jresult;
65203 }
65204
65205
65206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65207   int jresult ;
65208   int result;
65209
65210   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65211   jresult = (int)result;
65212   return jresult;
65213 }
65214
65215
65216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65217   int jresult ;
65218   int result;
65219
65220   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65221   jresult = (int)result;
65222   return jresult;
65223 }
65224
65225
65226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65227   int jresult ;
65228   int result;
65229
65230   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65231   jresult = (int)result;
65232   return jresult;
65233 }
65234
65235
65236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65237   int jresult ;
65238   int result;
65239
65240   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65241   jresult = (int)result;
65242   return jresult;
65243 }
65244
65245
65246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65247   int jresult ;
65248   int result;
65249
65250   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65251   jresult = (int)result;
65252   return jresult;
65253 }
65254
65255
65256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65257   void * jresult ;
65258   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65259
65260   {
65261     try {
65262       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65263     } catch (std::out_of_range& e) {
65264       {
65265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65266       };
65267     } catch (std::exception& e) {
65268       {
65269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65270       };
65271     } catch (...) {
65272       {
65273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65274       };
65275     }
65276   }
65277   jresult = (void *)result;
65278   return jresult;
65279 }
65280
65281
65282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65283   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65284
65285   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65286   {
65287     try {
65288       delete arg1;
65289     } catch (std::out_of_range& e) {
65290       {
65291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65292       };
65293     } catch (std::exception& e) {
65294       {
65295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65296       };
65297     } catch (...) {
65298       {
65299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65300       };
65301     }
65302   }
65303 }
65304
65305
65306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65307   int jresult ;
65308   int result;
65309
65310   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65311   jresult = (int)result;
65312   return jresult;
65313 }
65314
65315
65316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65317   int jresult ;
65318   int result;
65319
65320   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65321   jresult = (int)result;
65322   return jresult;
65323 }
65324
65325
65326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65327   int jresult ;
65328   int result;
65329
65330   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65331   jresult = (int)result;
65332   return jresult;
65333 }
65334
65335
65336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65337   void * jresult ;
65338   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65339
65340   {
65341     try {
65342       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65343     } catch (std::out_of_range& e) {
65344       {
65345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65346       };
65347     } catch (std::exception& e) {
65348       {
65349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65350       };
65351     } catch (...) {
65352       {
65353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65354       };
65355     }
65356   }
65357   jresult = (void *)result;
65358   return jresult;
65359 }
65360
65361
65362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65363   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65364
65365   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65366   {
65367     try {
65368       delete arg1;
65369     } catch (std::out_of_range& e) {
65370       {
65371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65372       };
65373     } catch (std::exception& e) {
65374       {
65375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65376       };
65377     } catch (...) {
65378       {
65379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65380       };
65381     }
65382   }
65383 }
65384
65385
65386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65387   void * jresult ;
65388   Dali::Toolkit::FlexContainer *result = 0 ;
65389
65390   {
65391     try {
65392       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65393     } catch (std::out_of_range& e) {
65394       {
65395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65396       };
65397     } catch (std::exception& e) {
65398       {
65399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65400       };
65401     } catch (...) {
65402       {
65403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65404       };
65405     }
65406   }
65407   jresult = (void *)result;
65408   return jresult;
65409 }
65410
65411
65412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65413   void * jresult ;
65414   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65415   Dali::Toolkit::FlexContainer *result = 0 ;
65416
65417   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65418   if (!arg1) {
65419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65420     return 0;
65421   }
65422   {
65423     try {
65424       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65425     } catch (std::out_of_range& e) {
65426       {
65427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65428       };
65429     } catch (std::exception& e) {
65430       {
65431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65432       };
65433     } catch (...) {
65434       {
65435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65436       };
65437     }
65438   }
65439   jresult = (void *)result;
65440   return jresult;
65441 }
65442
65443
65444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
65445   void * jresult ;
65446   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65447   Dali::Toolkit::FlexContainer *arg2 = 0 ;
65448   Dali::Toolkit::FlexContainer *result = 0 ;
65449
65450   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65451   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
65452   if (!arg2) {
65453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65454     return 0;
65455   }
65456   {
65457     try {
65458       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
65459     } catch (std::out_of_range& e) {
65460       {
65461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65462       };
65463     } catch (std::exception& e) {
65464       {
65465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65466       };
65467     } catch (...) {
65468       {
65469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65470       };
65471     }
65472   }
65473   jresult = (void *)result;
65474   return jresult;
65475 }
65476
65477
65478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
65479   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65480
65481   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65482   {
65483     try {
65484       delete arg1;
65485     } catch (std::out_of_range& e) {
65486       {
65487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65488       };
65489     } catch (std::exception& e) {
65490       {
65491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65492       };
65493     } catch (...) {
65494       {
65495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65496       };
65497     }
65498   }
65499 }
65500
65501
65502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
65503   void * jresult ;
65504   Dali::Toolkit::FlexContainer result;
65505
65506   {
65507     try {
65508       result = Dali::Toolkit::FlexContainer::New();
65509     } catch (std::out_of_range& e) {
65510       {
65511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65512       };
65513     } catch (std::exception& e) {
65514       {
65515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65516       };
65517     } catch (...) {
65518       {
65519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65520       };
65521     }
65522   }
65523   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65524   return jresult;
65525 }
65526
65527
65528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
65529   void * jresult ;
65530   Dali::BaseHandle arg1 ;
65531   Dali::BaseHandle *argp1 ;
65532   Dali::Toolkit::FlexContainer result;
65533
65534   argp1 = (Dali::BaseHandle *)jarg1;
65535   if (!argp1) {
65536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65537     return 0;
65538   }
65539   arg1 = *argp1;
65540   {
65541     try {
65542       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
65543     } catch (std::out_of_range& e) {
65544       {
65545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65546       };
65547     } catch (std::exception& e) {
65548       {
65549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65550       };
65551     } catch (...) {
65552       {
65553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65554       };
65555     }
65556   }
65557   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65558   return jresult;
65559 }
65560
65561
65562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
65563   int jresult ;
65564   int result;
65565
65566   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
65567   jresult = (int)result;
65568   return jresult;
65569 }
65570
65571
65572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
65573   int jresult ;
65574   int result;
65575
65576   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
65577   jresult = (int)result;
65578   return jresult;
65579 }
65580
65581
65582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
65583   int jresult ;
65584   int result;
65585
65586   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
65587   jresult = (int)result;
65588   return jresult;
65589 }
65590
65591
65592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
65593   int jresult ;
65594   int result;
65595
65596   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
65597   jresult = (int)result;
65598   return jresult;
65599 }
65600
65601
65602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
65603   void * jresult ;
65604   Dali::Toolkit::ImageView::Property *result = 0 ;
65605
65606   {
65607     try {
65608       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
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 = (void *)result;
65624   return jresult;
65625 }
65626
65627
65628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
65629   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
65630
65631   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
65632   {
65633     try {
65634       delete arg1;
65635     } catch (std::out_of_range& e) {
65636       {
65637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65638       };
65639     } catch (std::exception& e) {
65640       {
65641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65642       };
65643     } catch (...) {
65644       {
65645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65646       };
65647     }
65648   }
65649 }
65650
65651
65652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
65653   void * jresult ;
65654   Dali::Toolkit::ImageView *result = 0 ;
65655
65656   {
65657     try {
65658       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
65659     } catch (std::out_of_range& e) {
65660       {
65661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65662       };
65663     } catch (std::exception& e) {
65664       {
65665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65666       };
65667     } catch (...) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65670       };
65671     }
65672   }
65673   jresult = (void *)result;
65674   return jresult;
65675 }
65676
65677
65678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
65679   void * jresult ;
65680   Dali::Toolkit::ImageView result;
65681
65682   {
65683     try {
65684       result = Dali::Toolkit::ImageView::New();
65685     } catch (std::out_of_range& e) {
65686       {
65687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65688       };
65689     } catch (std::exception& e) {
65690       {
65691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65692       };
65693     } catch (...) {
65694       {
65695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65696       };
65697     }
65698   }
65699   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65700   return jresult;
65701 }
65702
65703
65704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
65705   void * jresult ;
65706   Dali::Image arg1 ;
65707   Dali::Image *argp1 ;
65708   Dali::Toolkit::ImageView result;
65709
65710   argp1 = (Dali::Image *)jarg1;
65711   if (!argp1) {
65712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65713     return 0;
65714   }
65715   arg1 = *argp1;
65716   {
65717     try {
65718       result = Dali::Toolkit::ImageView::New(arg1);
65719     } catch (std::out_of_range& e) {
65720       {
65721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65722       };
65723     } catch (std::exception& e) {
65724       {
65725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65726       };
65727     } catch (...) {
65728       {
65729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65730       };
65731     }
65732   }
65733   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65734   return jresult;
65735 }
65736
65737
65738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
65739   void * jresult ;
65740   std::string *arg1 = 0 ;
65741   Dali::Toolkit::ImageView result;
65742
65743   if (!jarg1) {
65744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65745     return 0;
65746   }
65747   std::string arg1_str(jarg1);
65748   arg1 = &arg1_str;
65749   {
65750     try {
65751       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
65752     } catch (std::out_of_range& e) {
65753       {
65754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65755       };
65756     } catch (std::exception& e) {
65757       {
65758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65759       };
65760     } catch (...) {
65761       {
65762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65763       };
65764     }
65765   }
65766   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65767
65768   //argout typemap for const std::string&
65769
65770   return jresult;
65771 }
65772
65773
65774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
65775   void * jresult ;
65776   std::string *arg1 = 0 ;
65777   Dali::ImageDimensions arg2 ;
65778   Dali::ImageDimensions *argp2 ;
65779   Dali::Toolkit::ImageView result;
65780
65781   if (!jarg1) {
65782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65783     return 0;
65784   }
65785   std::string arg1_str(jarg1);
65786   arg1 = &arg1_str;
65787   argp2 = (Dali::ImageDimensions *)jarg2;
65788   if (!argp2) {
65789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
65790     return 0;
65791   }
65792   arg2 = *argp2;
65793   {
65794     try {
65795       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
65796     } catch (std::out_of_range& e) {
65797       {
65798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65799       };
65800     } catch (std::exception& e) {
65801       {
65802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65803       };
65804     } catch (...) {
65805       {
65806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65807       };
65808     }
65809   }
65810   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65811
65812   //argout typemap for const std::string&
65813
65814   return jresult;
65815 }
65816
65817
65818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
65819   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
65820
65821   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65822   {
65823     try {
65824       delete arg1;
65825     } catch (std::out_of_range& e) {
65826       {
65827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65828       };
65829     } catch (std::exception& e) {
65830       {
65831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65832       };
65833     } catch (...) {
65834       {
65835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65836       };
65837     }
65838   }
65839 }
65840
65841
65842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
65843   void * jresult ;
65844   Dali::Toolkit::ImageView *arg1 = 0 ;
65845   Dali::Toolkit::ImageView *result = 0 ;
65846
65847   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65848   if (!arg1) {
65849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
65850     return 0;
65851   }
65852   {
65853     try {
65854       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
65855     } catch (std::out_of_range& e) {
65856       {
65857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65858       };
65859     } catch (std::exception& e) {
65860       {
65861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65862       };
65863     } catch (...) {
65864       {
65865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65866       };
65867     }
65868   }
65869   jresult = (void *)result;
65870   return jresult;
65871 }
65872
65873
65874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
65875   void * jresult ;
65876   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
65877   Dali::Toolkit::ImageView *arg2 = 0 ;
65878   Dali::Toolkit::ImageView *result = 0 ;
65879
65880   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65881   arg2 = (Dali::Toolkit::ImageView *)jarg2;
65882   if (!arg2) {
65883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
65884     return 0;
65885   }
65886   {
65887     try {
65888       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
65889     } catch (std::out_of_range& e) {
65890       {
65891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65892       };
65893     } catch (std::exception& e) {
65894       {
65895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65896       };
65897     } catch (...) {
65898       {
65899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65900       };
65901     }
65902   }
65903   jresult = (void *)result;
65904   return jresult;
65905 }
65906
65907
65908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
65909   void * jresult ;
65910   Dali::BaseHandle arg1 ;
65911   Dali::BaseHandle *argp1 ;
65912   Dali::Toolkit::ImageView result;
65913
65914   argp1 = (Dali::BaseHandle *)jarg1;
65915   if (!argp1) {
65916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65917     return 0;
65918   }
65919   arg1 = *argp1;
65920   {
65921     try {
65922       result = Dali::Toolkit::ImageView::DownCast(arg1);
65923     } catch (std::out_of_range& e) {
65924       {
65925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65926       };
65927     } catch (std::exception& e) {
65928       {
65929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65930       };
65931     } catch (...) {
65932       {
65933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65934       };
65935     }
65936   }
65937   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65938   return jresult;
65939 }
65940
65941
65942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
65943   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
65944   Dali::Image arg2 ;
65945   Dali::Image *argp2 ;
65946
65947   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65948   argp2 = (Dali::Image *)jarg2;
65949   if (!argp2) {
65950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65951     return ;
65952   }
65953   arg2 = *argp2;
65954   {
65955     try {
65956       (arg1)->SetImage(arg2);
65957     } catch (std::out_of_range& e) {
65958       {
65959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65960       };
65961     } catch (std::exception& e) {
65962       {
65963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65964       };
65965     } catch (...) {
65966       {
65967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65968       };
65969     }
65970   }
65971 }
65972
65973
65974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
65975   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
65976   std::string *arg2 = 0 ;
65977
65978   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65979   if (!jarg2) {
65980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65981     return ;
65982   }
65983   std::string arg2_str(jarg2);
65984   arg2 = &arg2_str;
65985   {
65986     try {
65987       (arg1)->SetImage((std::string const &)*arg2);
65988     } catch (std::out_of_range& e) {
65989       {
65990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65991       };
65992     } catch (std::exception& e) {
65993       {
65994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65995       };
65996     } catch (...) {
65997       {
65998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65999       };
66000     }
66001   }
66002
66003   //argout typemap for const std::string&
66004
66005 }
66006
66007
66008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66009   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66010   std::string *arg2 = 0 ;
66011   Dali::ImageDimensions arg3 ;
66012   Dali::ImageDimensions *argp3 ;
66013
66014   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66015   if (!jarg2) {
66016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66017     return ;
66018   }
66019   std::string arg2_str(jarg2);
66020   arg2 = &arg2_str;
66021   argp3 = (Dali::ImageDimensions *)jarg3;
66022   if (!argp3) {
66023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66024     return ;
66025   }
66026   arg3 = *argp3;
66027   {
66028     try {
66029       (arg1)->SetImage((std::string const &)*arg2,arg3);
66030     } catch (std::out_of_range& e) {
66031       {
66032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66033       };
66034     } catch (std::exception& e) {
66035       {
66036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66037       };
66038     } catch (...) {
66039       {
66040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66041       };
66042     }
66043   }
66044
66045   //argout typemap for const std::string&
66046
66047 }
66048
66049
66050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66051   void * jresult ;
66052   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66053   Dali::Image result;
66054
66055   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66056   {
66057     try {
66058       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66059     } catch (std::out_of_range& e) {
66060       {
66061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66062       };
66063     } catch (std::exception& e) {
66064       {
66065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66066       };
66067     } catch (...) {
66068       {
66069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66070       };
66071     }
66072   }
66073   jresult = new Dali::Image((const Dali::Image &)result);
66074   return jresult;
66075 }
66076
66077
66078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66079   int jresult ;
66080   int result;
66081
66082   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66083   jresult = (int)result;
66084   return jresult;
66085 }
66086
66087
66088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66089   int jresult ;
66090   int result;
66091
66092   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66093   jresult = (int)result;
66094   return jresult;
66095 }
66096
66097
66098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66099   int jresult ;
66100   int result;
66101
66102   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66103   jresult = (int)result;
66104   return jresult;
66105 }
66106
66107
66108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66109   int jresult ;
66110   int result;
66111
66112   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66113   jresult = (int)result;
66114   return jresult;
66115 }
66116
66117
66118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66119   int jresult ;
66120   int result;
66121
66122   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66123   jresult = (int)result;
66124   return jresult;
66125 }
66126
66127
66128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66129   int jresult ;
66130   int result;
66131
66132   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66133   jresult = (int)result;
66134   return jresult;
66135 }
66136
66137
66138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66139   int jresult ;
66140   int result;
66141
66142   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66143   jresult = (int)result;
66144   return jresult;
66145 }
66146
66147
66148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66149   int jresult ;
66150   int result;
66151
66152   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66153   jresult = (int)result;
66154   return jresult;
66155 }
66156
66157
66158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66159   void * jresult ;
66160   Dali::Toolkit::Model3dView::Property *result = 0 ;
66161
66162   {
66163     try {
66164       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66165     } catch (std::out_of_range& e) {
66166       {
66167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66168       };
66169     } catch (std::exception& e) {
66170       {
66171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66172       };
66173     } catch (...) {
66174       {
66175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66176       };
66177     }
66178   }
66179   jresult = (void *)result;
66180   return jresult;
66181 }
66182
66183
66184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66185   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66186
66187   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66188   {
66189     try {
66190       delete arg1;
66191     } catch (std::out_of_range& e) {
66192       {
66193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66194       };
66195     } catch (std::exception& e) {
66196       {
66197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66198       };
66199     } catch (...) {
66200       {
66201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66202       };
66203     }
66204   }
66205 }
66206
66207
66208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66209   void * jresult ;
66210   Dali::Toolkit::Model3dView result;
66211
66212   {
66213     try {
66214       result = Dali::Toolkit::Model3dView::New();
66215     } catch (std::out_of_range& e) {
66216       {
66217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66218       };
66219     } catch (std::exception& e) {
66220       {
66221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66222       };
66223     } catch (...) {
66224       {
66225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66226       };
66227     }
66228   }
66229   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66230   return jresult;
66231 }
66232
66233
66234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66235   void * jresult ;
66236   std::string *arg1 = 0 ;
66237   std::string *arg2 = 0 ;
66238   std::string *arg3 = 0 ;
66239   Dali::Toolkit::Model3dView result;
66240
66241   if (!jarg1) {
66242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66243     return 0;
66244   }
66245   std::string arg1_str(jarg1);
66246   arg1 = &arg1_str;
66247   if (!jarg2) {
66248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66249     return 0;
66250   }
66251   std::string arg2_str(jarg2);
66252   arg2 = &arg2_str;
66253   if (!jarg3) {
66254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66255     return 0;
66256   }
66257   std::string arg3_str(jarg3);
66258   arg3 = &arg3_str;
66259   {
66260     try {
66261       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66262     } catch (std::out_of_range& e) {
66263       {
66264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66265       };
66266     } catch (std::exception& e) {
66267       {
66268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66269       };
66270     } catch (...) {
66271       {
66272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66273       };
66274     }
66275   }
66276   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66277
66278   //argout typemap for const std::string&
66279
66280
66281   //argout typemap for const std::string&
66282
66283
66284   //argout typemap for const std::string&
66285
66286   return jresult;
66287 }
66288
66289
66290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66291   void * jresult ;
66292   Dali::Toolkit::Model3dView *result = 0 ;
66293
66294   {
66295     try {
66296       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66297     } catch (std::out_of_range& e) {
66298       {
66299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66300       };
66301     } catch (std::exception& e) {
66302       {
66303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66304       };
66305     } catch (...) {
66306       {
66307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66308       };
66309     }
66310   }
66311   jresult = (void *)result;
66312   return jresult;
66313 }
66314
66315
66316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66317   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66318
66319   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66320   {
66321     try {
66322       delete arg1;
66323     } catch (std::out_of_range& e) {
66324       {
66325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66326       };
66327     } catch (std::exception& e) {
66328       {
66329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66330       };
66331     } catch (...) {
66332       {
66333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66334       };
66335     }
66336   }
66337 }
66338
66339
66340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66341   void * jresult ;
66342   Dali::Toolkit::Model3dView *arg1 = 0 ;
66343   Dali::Toolkit::Model3dView *result = 0 ;
66344
66345   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66346   if (!arg1) {
66347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66348     return 0;
66349   }
66350   {
66351     try {
66352       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66353     } catch (std::out_of_range& e) {
66354       {
66355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66356       };
66357     } catch (std::exception& e) {
66358       {
66359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66360       };
66361     } catch (...) {
66362       {
66363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66364       };
66365     }
66366   }
66367   jresult = (void *)result;
66368   return jresult;
66369 }
66370
66371
66372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66373   void * jresult ;
66374   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66375   Dali::Toolkit::Model3dView *arg2 = 0 ;
66376   Dali::Toolkit::Model3dView *result = 0 ;
66377
66378   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66379   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66380   if (!arg2) {
66381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66382     return 0;
66383   }
66384   {
66385     try {
66386       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66387     } catch (std::out_of_range& e) {
66388       {
66389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66390       };
66391     } catch (std::exception& e) {
66392       {
66393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66394       };
66395     } catch (...) {
66396       {
66397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66398       };
66399     }
66400   }
66401   jresult = (void *)result;
66402   return jresult;
66403 }
66404
66405
66406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66407   void * jresult ;
66408   Dali::BaseHandle arg1 ;
66409   Dali::BaseHandle *argp1 ;
66410   Dali::Toolkit::Model3dView result;
66411
66412   argp1 = (Dali::BaseHandle *)jarg1;
66413   if (!argp1) {
66414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66415     return 0;
66416   }
66417   arg1 = *argp1;
66418   {
66419     try {
66420       result = Dali::Toolkit::Model3dView::DownCast(arg1);
66421     } catch (std::out_of_range& e) {
66422       {
66423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66424       };
66425     } catch (std::exception& e) {
66426       {
66427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66428       };
66429     } catch (...) {
66430       {
66431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66432       };
66433     }
66434   }
66435   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66436   return jresult;
66437 }
66438
66439
66440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
66441   int jresult ;
66442   int result;
66443
66444   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
66445   jresult = (int)result;
66446   return jresult;
66447 }
66448
66449
66450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
66451   int jresult ;
66452   int result;
66453
66454   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
66455   jresult = (int)result;
66456   return jresult;
66457 }
66458
66459
66460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
66461   int jresult ;
66462   int result;
66463
66464   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
66465   jresult = (int)result;
66466   return jresult;
66467 }
66468
66469
66470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
66471   int jresult ;
66472   int result;
66473
66474   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
66475   jresult = (int)result;
66476   return jresult;
66477 }
66478
66479
66480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
66481   int jresult ;
66482   int result;
66483
66484   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
66485   jresult = (int)result;
66486   return jresult;
66487 }
66488
66489
66490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
66491   int jresult ;
66492   int result;
66493
66494   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
66495   jresult = (int)result;
66496   return jresult;
66497 }
66498
66499
66500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
66501   int jresult ;
66502   int result;
66503
66504   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
66505   jresult = (int)result;
66506   return jresult;
66507 }
66508
66509
66510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
66511   int jresult ;
66512   int result;
66513
66514   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
66515   jresult = (int)result;
66516   return jresult;
66517 }
66518
66519
66520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
66521   int jresult ;
66522   int result;
66523
66524   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
66525   jresult = (int)result;
66526   return jresult;
66527 }
66528
66529
66530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
66531   void * jresult ;
66532   Dali::Toolkit::ScrollBar::Property *result = 0 ;
66533
66534   {
66535     try {
66536       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
66537     } catch (std::out_of_range& e) {
66538       {
66539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66540       };
66541     } catch (std::exception& e) {
66542       {
66543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66544       };
66545     } catch (...) {
66546       {
66547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66548       };
66549     }
66550   }
66551   jresult = (void *)result;
66552   return jresult;
66553 }
66554
66555
66556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
66557   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
66558
66559   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
66560   {
66561     try {
66562       delete arg1;
66563     } catch (std::out_of_range& e) {
66564       {
66565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66566       };
66567     } catch (std::exception& e) {
66568       {
66569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66570       };
66571     } catch (...) {
66572       {
66573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66574       };
66575     }
66576   }
66577 }
66578
66579
66580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
66581   void * jresult ;
66582   Dali::Toolkit::ScrollBar *result = 0 ;
66583
66584   {
66585     try {
66586       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
66587     } catch (std::out_of_range& e) {
66588       {
66589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66590       };
66591     } catch (std::exception& e) {
66592       {
66593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66594       };
66595     } catch (...) {
66596       {
66597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66598       };
66599     }
66600   }
66601   jresult = (void *)result;
66602   return jresult;
66603 }
66604
66605
66606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
66607   void * jresult ;
66608   Dali::Toolkit::ScrollBar *arg1 = 0 ;
66609   Dali::Toolkit::ScrollBar *result = 0 ;
66610
66611   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66612   if (!arg1) {
66613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
66614     return 0;
66615   }
66616   {
66617     try {
66618       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
66619     } catch (std::out_of_range& e) {
66620       {
66621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66622       };
66623     } catch (std::exception& e) {
66624       {
66625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66626       };
66627     } catch (...) {
66628       {
66629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66630       };
66631     }
66632   }
66633   jresult = (void *)result;
66634   return jresult;
66635 }
66636
66637
66638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
66639   void * jresult ;
66640   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66641   Dali::Toolkit::ScrollBar *arg2 = 0 ;
66642   Dali::Toolkit::ScrollBar *result = 0 ;
66643
66644   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66645   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
66646   if (!arg2) {
66647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
66648     return 0;
66649   }
66650   {
66651     try {
66652       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*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 = (void *)result;
66668   return jresult;
66669 }
66670
66671
66672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
66673   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66674
66675   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66676   {
66677     try {
66678       delete arg1;
66679     } catch (std::out_of_range& e) {
66680       {
66681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66682       };
66683     } catch (std::exception& e) {
66684       {
66685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66686       };
66687     } catch (...) {
66688       {
66689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66690       };
66691     }
66692   }
66693 }
66694
66695
66696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
66697   void * jresult ;
66698   Dali::Toolkit::ScrollBar::Direction arg1 ;
66699   Dali::Toolkit::ScrollBar result;
66700
66701   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
66702   {
66703     try {
66704       result = Dali::Toolkit::ScrollBar::New(arg1);
66705     } catch (std::out_of_range& e) {
66706       {
66707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66708       };
66709     } catch (std::exception& e) {
66710       {
66711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66712       };
66713     } catch (...) {
66714       {
66715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66716       };
66717     }
66718   }
66719   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
66720   return jresult;
66721 }
66722
66723
66724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
66725   void * jresult ;
66726   Dali::Toolkit::ScrollBar result;
66727
66728   {
66729     try {
66730       result = Dali::Toolkit::ScrollBar::New();
66731     } catch (std::out_of_range& e) {
66732       {
66733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66734       };
66735     } catch (std::exception& e) {
66736       {
66737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66738       };
66739     } catch (...) {
66740       {
66741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66742       };
66743     }
66744   }
66745   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
66746   return jresult;
66747 }
66748
66749
66750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
66751   void * jresult ;
66752   Dali::BaseHandle arg1 ;
66753   Dali::BaseHandle *argp1 ;
66754   Dali::Toolkit::ScrollBar result;
66755
66756   argp1 = (Dali::BaseHandle *)jarg1;
66757   if (!argp1) {
66758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66759     return 0;
66760   }
66761   arg1 = *argp1;
66762   {
66763     try {
66764       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
66765     } catch (std::out_of_range& e) {
66766       {
66767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66768       };
66769     } catch (std::exception& e) {
66770       {
66771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66772       };
66773     } catch (...) {
66774       {
66775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66776       };
66777     }
66778   }
66779   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
66780   return jresult;
66781 }
66782
66783
66784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
66785   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66786   Dali::Handle arg2 ;
66787   Dali::Property::Index arg3 ;
66788   Dali::Property::Index arg4 ;
66789   Dali::Property::Index arg5 ;
66790   Dali::Property::Index arg6 ;
66791   Dali::Handle *argp2 ;
66792
66793   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66794   argp2 = (Dali::Handle *)jarg2;
66795   if (!argp2) {
66796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
66797     return ;
66798   }
66799   arg2 = *argp2;
66800   arg3 = (Dali::Property::Index)jarg3;
66801   arg4 = (Dali::Property::Index)jarg4;
66802   arg5 = (Dali::Property::Index)jarg5;
66803   arg6 = (Dali::Property::Index)jarg6;
66804   {
66805     try {
66806       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
66807     } catch (std::out_of_range& e) {
66808       {
66809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66810       };
66811     } catch (std::exception& e) {
66812       {
66813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66814       };
66815     } catch (...) {
66816       {
66817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66818       };
66819     }
66820   }
66821 }
66822
66823
66824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
66825   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66826   Dali::Actor arg2 ;
66827   Dali::Actor *argp2 ;
66828
66829   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66830   argp2 = (Dali::Actor *)jarg2;
66831   if (!argp2) {
66832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66833     return ;
66834   }
66835   arg2 = *argp2;
66836   {
66837     try {
66838       (arg1)->SetScrollIndicator(arg2);
66839     } catch (std::out_of_range& e) {
66840       {
66841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66842       };
66843     } catch (std::exception& e) {
66844       {
66845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66846       };
66847     } catch (...) {
66848       {
66849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66850       };
66851     }
66852   }
66853 }
66854
66855
66856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
66857   void * jresult ;
66858   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66859   Dali::Actor result;
66860
66861   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66862   {
66863     try {
66864       result = (arg1)->GetScrollIndicator();
66865     } catch (std::out_of_range& e) {
66866       {
66867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66868       };
66869     } catch (std::exception& e) {
66870       {
66871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66872       };
66873     } catch (...) {
66874       {
66875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66876       };
66877     }
66878   }
66879   jresult = new Dali::Actor((const Dali::Actor &)result);
66880   return jresult;
66881 }
66882
66883
66884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
66885   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66886   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
66887
66888   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66889   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
66890   if (!arg2) {
66891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
66892     return ;
66893   }
66894   {
66895     try {
66896       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
66897     } catch (std::out_of_range& e) {
66898       {
66899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66900       };
66901     } catch (std::exception& e) {
66902       {
66903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66904       };
66905     } catch (...) {
66906       {
66907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66908       };
66909     }
66910   }
66911 }
66912
66913
66914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
66915   void * jresult ;
66916   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66917   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
66918
66919   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66920   {
66921     try {
66922       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
66923     } catch (std::out_of_range& e) {
66924       {
66925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66926       };
66927     } catch (std::exception& e) {
66928       {
66929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66930       };
66931     } catch (...) {
66932       {
66933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66934       };
66935     }
66936   }
66937   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
66938   return jresult;
66939 }
66940
66941
66942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
66943   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66944   Dali::Toolkit::ScrollBar::Direction arg2 ;
66945
66946   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66947   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
66948   {
66949     try {
66950       (arg1)->SetScrollDirection(arg2);
66951     } catch (std::out_of_range& e) {
66952       {
66953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66954       };
66955     } catch (std::exception& e) {
66956       {
66957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66958       };
66959     } catch (...) {
66960       {
66961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66962       };
66963     }
66964   }
66965 }
66966
66967
66968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
66969   int jresult ;
66970   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66971   Dali::Toolkit::ScrollBar::Direction result;
66972
66973   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66974   {
66975     try {
66976       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
66977     } catch (std::out_of_range& e) {
66978       {
66979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66980       };
66981     } catch (std::exception& e) {
66982       {
66983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66984       };
66985     } catch (...) {
66986       {
66987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66988       };
66989     }
66990   }
66991   jresult = (int)result;
66992   return jresult;
66993 }
66994
66995
66996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
66997   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66998   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
66999
67000   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67001   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67002   {
67003     try {
67004       (arg1)->SetIndicatorHeightPolicy(arg2);
67005     } catch (std::out_of_range& e) {
67006       {
67007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67008       };
67009     } catch (std::exception& e) {
67010       {
67011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67012       };
67013     } catch (...) {
67014       {
67015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67016       };
67017     }
67018   }
67019 }
67020
67021
67022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67023   int jresult ;
67024   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67025   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67026
67027   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67028   {
67029     try {
67030       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67031     } catch (std::out_of_range& e) {
67032       {
67033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67034       };
67035     } catch (std::exception& e) {
67036       {
67037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67038       };
67039     } catch (...) {
67040       {
67041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67042       };
67043     }
67044   }
67045   jresult = (int)result;
67046   return jresult;
67047 }
67048
67049
67050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67051   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67052   float arg2 ;
67053
67054   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67055   arg2 = (float)jarg2;
67056   {
67057     try {
67058       (arg1)->SetIndicatorFixedHeight(arg2);
67059     } catch (std::out_of_range& e) {
67060       {
67061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67062       };
67063     } catch (std::exception& e) {
67064       {
67065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67066       };
67067     } catch (...) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67070       };
67071     }
67072   }
67073 }
67074
67075
67076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67077   float jresult ;
67078   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67079   float result;
67080
67081   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67082   {
67083     try {
67084       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67085     } catch (std::out_of_range& e) {
67086       {
67087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67088       };
67089     } catch (std::exception& e) {
67090       {
67091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67092       };
67093     } catch (...) {
67094       {
67095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67096       };
67097     }
67098   }
67099   jresult = result;
67100   return jresult;
67101 }
67102
67103
67104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67105   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67106   float arg2 ;
67107
67108   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67109   arg2 = (float)jarg2;
67110   {
67111     try {
67112       (arg1)->SetIndicatorShowDuration(arg2);
67113     } catch (std::out_of_range& e) {
67114       {
67115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67116       };
67117     } catch (std::exception& e) {
67118       {
67119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67120       };
67121     } catch (...) {
67122       {
67123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67124       };
67125     }
67126   }
67127 }
67128
67129
67130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67131   float jresult ;
67132   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67133   float result;
67134
67135   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67136   {
67137     try {
67138       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67139     } catch (std::out_of_range& e) {
67140       {
67141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67142       };
67143     } catch (std::exception& e) {
67144       {
67145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67146       };
67147     } catch (...) {
67148       {
67149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67150       };
67151     }
67152   }
67153   jresult = result;
67154   return jresult;
67155 }
67156
67157
67158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67159   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67160   float arg2 ;
67161
67162   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67163   arg2 = (float)jarg2;
67164   {
67165     try {
67166       (arg1)->SetIndicatorHideDuration(arg2);
67167     } catch (std::out_of_range& e) {
67168       {
67169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67170       };
67171     } catch (std::exception& e) {
67172       {
67173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67174       };
67175     } catch (...) {
67176       {
67177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67178       };
67179     }
67180   }
67181 }
67182
67183
67184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67185   float jresult ;
67186   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67187   float result;
67188
67189   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67190   {
67191     try {
67192       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67193     } catch (std::out_of_range& e) {
67194       {
67195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67196       };
67197     } catch (std::exception& e) {
67198       {
67199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67200       };
67201     } catch (...) {
67202       {
67203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67204       };
67205     }
67206   }
67207   jresult = result;
67208   return jresult;
67209 }
67210
67211
67212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67213   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67214
67215   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67216   {
67217     try {
67218       (arg1)->ShowIndicator();
67219     } catch (std::out_of_range& e) {
67220       {
67221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67222       };
67223     } catch (std::exception& e) {
67224       {
67225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67226       };
67227     } catch (...) {
67228       {
67229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67230       };
67231     }
67232   }
67233 }
67234
67235
67236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67237   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67238
67239   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67240   {
67241     try {
67242       (arg1)->HideIndicator();
67243     } catch (std::out_of_range& e) {
67244       {
67245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67246       };
67247     } catch (std::exception& e) {
67248       {
67249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67250       };
67251     } catch (...) {
67252       {
67253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67254       };
67255     }
67256   }
67257 }
67258
67259
67260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67261   void * jresult ;
67262   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67263   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67264
67265   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67266   {
67267     try {
67268       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67269     } catch (std::out_of_range& e) {
67270       {
67271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67272       };
67273     } catch (std::exception& e) {
67274       {
67275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67276       };
67277     } catch (...) {
67278       {
67279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67280       };
67281     }
67282   }
67283   jresult = (void *)result;
67284   return jresult;
67285 }
67286
67287
67288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67289   void * jresult ;
67290   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67291   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67292
67293   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67294   {
67295     try {
67296       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67297     } catch (std::out_of_range& e) {
67298       {
67299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67300       };
67301     } catch (std::exception& e) {
67302       {
67303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67304       };
67305     } catch (...) {
67306       {
67307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67308       };
67309     }
67310   }
67311   jresult = (void *)result;
67312   return jresult;
67313 }
67314
67315
67316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67317   int jresult ;
67318   int result;
67319
67320   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67321   jresult = (int)result;
67322   return jresult;
67323 }
67324
67325
67326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67327   int jresult ;
67328   int result;
67329
67330   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67331   jresult = (int)result;
67332   return jresult;
67333 }
67334
67335
67336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67337   int jresult ;
67338   int result;
67339
67340   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67341   jresult = (int)result;
67342   return jresult;
67343 }
67344
67345
67346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67347   int jresult ;
67348   int result;
67349
67350   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67351   jresult = (int)result;
67352   return jresult;
67353 }
67354
67355
67356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67357   int jresult ;
67358   int result;
67359
67360   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67361   jresult = (int)result;
67362   return jresult;
67363 }
67364
67365
67366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67367   int jresult ;
67368   int result;
67369
67370   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67371   jresult = (int)result;
67372   return jresult;
67373 }
67374
67375
67376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67377   int jresult ;
67378   int result;
67379
67380   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67381   jresult = (int)result;
67382   return jresult;
67383 }
67384
67385
67386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67387   int jresult ;
67388   int result;
67389
67390   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67391   jresult = (int)result;
67392   return jresult;
67393 }
67394
67395
67396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67397   int jresult ;
67398   int result;
67399
67400   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67401   jresult = (int)result;
67402   return jresult;
67403 }
67404
67405
67406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
67407   int jresult ;
67408   int result;
67409
67410   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
67411   jresult = (int)result;
67412   return jresult;
67413 }
67414
67415
67416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
67417   int jresult ;
67418   int result;
67419
67420   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
67421   jresult = (int)result;
67422   return jresult;
67423 }
67424
67425
67426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
67427   int jresult ;
67428   int result;
67429
67430   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
67431   jresult = (int)result;
67432   return jresult;
67433 }
67434
67435
67436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
67437   int jresult ;
67438   int result;
67439
67440   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
67441   jresult = (int)result;
67442   return jresult;
67443 }
67444
67445
67446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
67447   int jresult ;
67448   int result;
67449
67450   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
67451   jresult = (int)result;
67452   return jresult;
67453 }
67454
67455
67456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
67457   void * jresult ;
67458   Dali::Toolkit::Scrollable::Property *result = 0 ;
67459
67460   {
67461     try {
67462       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
67463     } catch (std::out_of_range& e) {
67464       {
67465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67466       };
67467     } catch (std::exception& e) {
67468       {
67469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67470       };
67471     } catch (...) {
67472       {
67473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67474       };
67475     }
67476   }
67477   jresult = (void *)result;
67478   return jresult;
67479 }
67480
67481
67482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
67483   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
67484
67485   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
67486   {
67487     try {
67488       delete arg1;
67489     } catch (std::out_of_range& e) {
67490       {
67491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67492       };
67493     } catch (std::exception& e) {
67494       {
67495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67496       };
67497     } catch (...) {
67498       {
67499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67500       };
67501     }
67502   }
67503 }
67504
67505
67506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
67507   void * jresult ;
67508   Dali::Toolkit::Scrollable *result = 0 ;
67509
67510   {
67511     try {
67512       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
67513     } catch (std::out_of_range& e) {
67514       {
67515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67516       };
67517     } catch (std::exception& e) {
67518       {
67519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67520       };
67521     } catch (...) {
67522       {
67523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67524       };
67525     }
67526   }
67527   jresult = (void *)result;
67528   return jresult;
67529 }
67530
67531
67532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
67533   void * jresult ;
67534   Dali::Toolkit::Scrollable *arg1 = 0 ;
67535   Dali::Toolkit::Scrollable *result = 0 ;
67536
67537   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67538   if (!arg1) {
67539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67540     return 0;
67541   }
67542   {
67543     try {
67544       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
67545     } catch (std::out_of_range& e) {
67546       {
67547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67548       };
67549     } catch (std::exception& e) {
67550       {
67551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67552       };
67553     } catch (...) {
67554       {
67555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67556       };
67557     }
67558   }
67559   jresult = (void *)result;
67560   return jresult;
67561 }
67562
67563
67564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
67565   void * jresult ;
67566   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67567   Dali::Toolkit::Scrollable *arg2 = 0 ;
67568   Dali::Toolkit::Scrollable *result = 0 ;
67569
67570   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67571   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
67572   if (!arg2) {
67573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67574     return 0;
67575   }
67576   {
67577     try {
67578       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
67579     } catch (std::out_of_range& e) {
67580       {
67581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67582       };
67583     } catch (std::exception& e) {
67584       {
67585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67586       };
67587     } catch (...) {
67588       {
67589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67590       };
67591     }
67592   }
67593   jresult = (void *)result;
67594   return jresult;
67595 }
67596
67597
67598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
67599   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67600
67601   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67602   {
67603     try {
67604       delete arg1;
67605     } catch (std::out_of_range& e) {
67606       {
67607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67608       };
67609     } catch (std::exception& e) {
67610       {
67611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67612       };
67613     } catch (...) {
67614       {
67615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67616       };
67617     }
67618   }
67619 }
67620
67621
67622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
67623   void * jresult ;
67624   Dali::BaseHandle arg1 ;
67625   Dali::BaseHandle *argp1 ;
67626   Dali::Toolkit::Scrollable result;
67627
67628   argp1 = (Dali::BaseHandle *)jarg1;
67629   if (!argp1) {
67630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67631     return 0;
67632   }
67633   arg1 = *argp1;
67634   {
67635     try {
67636       result = Dali::Toolkit::Scrollable::DownCast(arg1);
67637     } catch (std::out_of_range& e) {
67638       {
67639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67640       };
67641     } catch (std::exception& e) {
67642       {
67643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67644       };
67645     } catch (...) {
67646       {
67647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67648       };
67649     }
67650   }
67651   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
67652   return jresult;
67653 }
67654
67655
67656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
67657   unsigned int jresult ;
67658   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67659   bool result;
67660
67661   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67662   {
67663     try {
67664       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
67665     } catch (std::out_of_range& e) {
67666       {
67667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67668       };
67669     } catch (std::exception& e) {
67670       {
67671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67672       };
67673     } catch (...) {
67674       {
67675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67676       };
67677     }
67678   }
67679   jresult = result;
67680   return jresult;
67681 }
67682
67683
67684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
67685   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67686   bool arg2 ;
67687
67688   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67689   arg2 = jarg2 ? true : false;
67690   {
67691     try {
67692       (arg1)->SetOvershootEnabled(arg2);
67693     } catch (std::out_of_range& e) {
67694       {
67695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67696       };
67697     } catch (std::exception& e) {
67698       {
67699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67700       };
67701     } catch (...) {
67702       {
67703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67704       };
67705     }
67706   }
67707 }
67708
67709
67710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
67711   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67712   Dali::Vector4 *arg2 = 0 ;
67713
67714   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67715   arg2 = (Dali::Vector4 *)jarg2;
67716   if (!arg2) {
67717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67718     return ;
67719   }
67720   {
67721     try {
67722       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
67723     } catch (std::out_of_range& e) {
67724       {
67725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67726       };
67727     } catch (std::exception& e) {
67728       {
67729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67730       };
67731     } catch (...) {
67732       {
67733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67734       };
67735     }
67736   }
67737 }
67738
67739
67740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
67741   void * jresult ;
67742   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67743   Dali::Vector4 result;
67744
67745   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67746   {
67747     try {
67748       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
67749     } catch (std::out_of_range& e) {
67750       {
67751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67752       };
67753     } catch (std::exception& e) {
67754       {
67755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67756       };
67757     } catch (...) {
67758       {
67759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67760       };
67761     }
67762   }
67763   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67764   return jresult;
67765 }
67766
67767
67768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
67769   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67770   float arg2 ;
67771
67772   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67773   arg2 = (float)jarg2;
67774   {
67775     try {
67776       (arg1)->SetOvershootAnimationSpeed(arg2);
67777     } catch (std::out_of_range& e) {
67778       {
67779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67780       };
67781     } catch (std::exception& e) {
67782       {
67783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67784       };
67785     } catch (...) {
67786       {
67787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67788       };
67789     }
67790   }
67791 }
67792
67793
67794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
67795   float jresult ;
67796   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67797   float result;
67798
67799   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67800   {
67801     try {
67802       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
67803     } catch (std::out_of_range& e) {
67804       {
67805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67806       };
67807     } catch (std::exception& e) {
67808       {
67809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67810       };
67811     } catch (...) {
67812       {
67813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67814       };
67815     }
67816   }
67817   jresult = result;
67818   return jresult;
67819 }
67820
67821
67822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
67823   void * jresult ;
67824   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67825   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
67826
67827   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67828   {
67829     try {
67830       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
67831     } catch (std::out_of_range& e) {
67832       {
67833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67834       };
67835     } catch (std::exception& e) {
67836       {
67837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67838       };
67839     } catch (...) {
67840       {
67841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67842       };
67843     }
67844   }
67845   jresult = (void *)result;
67846   return jresult;
67847 }
67848
67849
67850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
67851   void * jresult ;
67852   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67853   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
67854
67855   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67856   {
67857     try {
67858       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
67859     } catch (std::out_of_range& e) {
67860       {
67861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67862       };
67863     } catch (std::exception& e) {
67864       {
67865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67866       };
67867     } catch (...) {
67868       {
67869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67870       };
67871     }
67872   }
67873   jresult = (void *)result;
67874   return jresult;
67875 }
67876
67877
67878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
67879   void * jresult ;
67880   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67881   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
67882
67883   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67884   {
67885     try {
67886       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
67887     } catch (std::out_of_range& e) {
67888       {
67889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67890       };
67891     } catch (std::exception& e) {
67892       {
67893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67894       };
67895     } catch (...) {
67896       {
67897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67898       };
67899     }
67900   }
67901   jresult = (void *)result;
67902   return jresult;
67903 }
67904
67905
67906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
67907   unsigned int jresult ;
67908   Dali::Toolkit::ControlOrientation::Type arg1 ;
67909   bool result;
67910
67911   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
67912   {
67913     try {
67914       result = (bool)Dali::Toolkit::IsVertical(arg1);
67915     } catch (std::out_of_range& e) {
67916       {
67917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67918       };
67919     } catch (std::exception& e) {
67920       {
67921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67922       };
67923     } catch (...) {
67924       {
67925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67926       };
67927     }
67928   }
67929   jresult = result;
67930   return jresult;
67931 }
67932
67933
67934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
67935   unsigned int jresult ;
67936   Dali::Toolkit::ControlOrientation::Type arg1 ;
67937   bool result;
67938
67939   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
67940   {
67941     try {
67942       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
67943     } catch (std::out_of_range& e) {
67944       {
67945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67946       };
67947     } catch (std::exception& e) {
67948       {
67949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67950       };
67951     } catch (...) {
67952       {
67953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67954       };
67955     }
67956   }
67957   jresult = result;
67958   return jresult;
67959 }
67960
67961
67962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
67963   void * jresult ;
67964   unsigned int arg1 ;
67965   unsigned int arg2 ;
67966   Dali::Toolkit::ItemRange *result = 0 ;
67967
67968   arg1 = (unsigned int)jarg1;
67969   arg2 = (unsigned int)jarg2;
67970   {
67971     try {
67972       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
67973     } catch (std::out_of_range& e) {
67974       {
67975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67976       };
67977     } catch (std::exception& e) {
67978       {
67979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67980       };
67981     } catch (...) {
67982       {
67983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67984       };
67985     }
67986   }
67987   jresult = (void *)result;
67988   return jresult;
67989 }
67990
67991
67992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
67993   void * jresult ;
67994   Dali::Toolkit::ItemRange *arg1 = 0 ;
67995   Dali::Toolkit::ItemRange *result = 0 ;
67996
67997   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
67998   if (!arg1) {
67999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68000     return 0;
68001   }
68002   {
68003     try {
68004       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68005     } catch (std::out_of_range& e) {
68006       {
68007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68008       };
68009     } catch (std::exception& e) {
68010       {
68011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68012       };
68013     } catch (...) {
68014       {
68015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68016       };
68017     }
68018   }
68019   jresult = (void *)result;
68020   return jresult;
68021 }
68022
68023
68024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68025   void * jresult ;
68026   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68027   Dali::Toolkit::ItemRange *arg2 = 0 ;
68028   Dali::Toolkit::ItemRange *result = 0 ;
68029
68030   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68031   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68032   if (!arg2) {
68033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68034     return 0;
68035   }
68036   {
68037     try {
68038       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68039     } catch (std::out_of_range& e) {
68040       {
68041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68042       };
68043     } catch (std::exception& e) {
68044       {
68045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68046       };
68047     } catch (...) {
68048       {
68049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68050       };
68051     }
68052   }
68053   jresult = (void *)result;
68054   return jresult;
68055 }
68056
68057
68058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68059   unsigned int jresult ;
68060   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68061   unsigned int arg2 ;
68062   bool result;
68063
68064   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68065   arg2 = (unsigned int)jarg2;
68066   {
68067     try {
68068       result = (bool)(arg1)->Within(arg2);
68069     } catch (std::out_of_range& e) {
68070       {
68071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68072       };
68073     } catch (std::exception& e) {
68074       {
68075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68076       };
68077     } catch (...) {
68078       {
68079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68080       };
68081     }
68082   }
68083   jresult = result;
68084   return jresult;
68085 }
68086
68087
68088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68089   void * jresult ;
68090   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68091   Dali::Toolkit::ItemRange *arg2 = 0 ;
68092   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68093
68094   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68095   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68096   if (!arg2) {
68097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68098     return 0;
68099   }
68100   {
68101     try {
68102       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68103     } catch (std::out_of_range& e) {
68104       {
68105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68106       };
68107     } catch (std::exception& e) {
68108       {
68109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68110       };
68111     } catch (...) {
68112       {
68113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68114       };
68115     }
68116   }
68117   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68118   return jresult;
68119 }
68120
68121
68122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68123   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68124   unsigned int arg2 ;
68125
68126   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68127   arg2 = (unsigned int)jarg2;
68128   if (arg1) (arg1)->begin = arg2;
68129 }
68130
68131
68132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68133   unsigned int jresult ;
68134   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68135   unsigned int result;
68136
68137   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68138   result = (unsigned int) ((arg1)->begin);
68139   jresult = result;
68140   return jresult;
68141 }
68142
68143
68144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68145   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68146   unsigned int arg2 ;
68147
68148   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68149   arg2 = (unsigned int)jarg2;
68150   if (arg1) (arg1)->end = arg2;
68151 }
68152
68153
68154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68155   unsigned int jresult ;
68156   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68157   unsigned int result;
68158
68159   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68160   result = (unsigned int) ((arg1)->end);
68161   jresult = result;
68162   return jresult;
68163 }
68164
68165
68166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68167   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68168
68169   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68170   {
68171     try {
68172       delete arg1;
68173     } catch (std::out_of_range& e) {
68174       {
68175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68176       };
68177     } catch (std::exception& e) {
68178       {
68179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68180       };
68181     } catch (...) {
68182       {
68183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68184       };
68185     }
68186   }
68187 }
68188
68189
68190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68191   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68192
68193   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68194   {
68195     try {
68196       delete arg1;
68197     } catch (std::out_of_range& e) {
68198       {
68199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68200       };
68201     } catch (std::exception& e) {
68202       {
68203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68204       };
68205     } catch (...) {
68206       {
68207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68208       };
68209     }
68210   }
68211 }
68212
68213
68214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68215   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68216   Dali::Toolkit::ControlOrientation::Type arg2 ;
68217
68218   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68219   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68220   {
68221     try {
68222       (arg1)->SetOrientation(arg2);
68223     } catch (std::out_of_range& e) {
68224       {
68225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68226       };
68227     } catch (std::exception& e) {
68228       {
68229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68230       };
68231     } catch (...) {
68232       {
68233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68234       };
68235     }
68236   }
68237 }
68238
68239
68240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68241   int jresult ;
68242   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68243   Dali::Toolkit::ControlOrientation::Type result;
68244
68245   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68246   {
68247     try {
68248       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68249     } catch (std::out_of_range& e) {
68250       {
68251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68252       };
68253     } catch (std::exception& e) {
68254       {
68255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68256       };
68257     } catch (...) {
68258       {
68259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68260       };
68261     }
68262   }
68263   jresult = (int)result;
68264   return jresult;
68265 }
68266
68267
68268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68269   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68270   Dali::Property::Map *arg2 = 0 ;
68271
68272   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68273   arg2 = (Dali::Property::Map *)jarg2;
68274   if (!arg2) {
68275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68276     return ;
68277   }
68278   {
68279     try {
68280       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68281     } catch (std::out_of_range& e) {
68282       {
68283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68284       };
68285     } catch (std::exception& e) {
68286       {
68287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68288       };
68289     } catch (...) {
68290       {
68291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68292       };
68293     }
68294   }
68295 }
68296
68297
68298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68299   void * jresult ;
68300   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68301   Dali::Property::Map result;
68302
68303   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68304   {
68305     try {
68306       result = (arg1)->GetLayoutProperties();
68307     } catch (std::out_of_range& e) {
68308       {
68309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68310       };
68311     } catch (std::exception& e) {
68312       {
68313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68314       };
68315     } catch (...) {
68316       {
68317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68318       };
68319     }
68320   }
68321   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
68322   return jresult;
68323 }
68324
68325
68326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68327   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68328   unsigned int arg2 ;
68329   Dali::Vector3 *arg3 = 0 ;
68330   Dali::Vector3 *arg4 = 0 ;
68331
68332   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68333   arg2 = (unsigned int)jarg2;
68334   arg3 = (Dali::Vector3 *)jarg3;
68335   if (!arg3) {
68336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68337     return ;
68338   }
68339   arg4 = (Dali::Vector3 *)jarg4;
68340   if (!arg4) {
68341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68342     return ;
68343   }
68344   {
68345     try {
68346       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68347     } catch (std::out_of_range& e) {
68348       {
68349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68350       };
68351     } catch (std::exception& e) {
68352       {
68353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68354       };
68355     } catch (...) {
68356       {
68357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68358       };
68359     }
68360   }
68361 }
68362
68363
68364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68365   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68366   Dali::Vector3 *arg2 = 0 ;
68367
68368   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68369   arg2 = (Dali::Vector3 *)jarg2;
68370   if (!arg2) {
68371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68372     return ;
68373   }
68374   {
68375     try {
68376       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68377     } catch (std::out_of_range& e) {
68378       {
68379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68380       };
68381     } catch (std::exception& e) {
68382       {
68383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68384       };
68385     } catch (...) {
68386       {
68387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68388       };
68389     }
68390   }
68391 }
68392
68393
68394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68395   float jresult ;
68396   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68397   unsigned int arg2 ;
68398   Dali::Vector3 arg3 ;
68399   Dali::Vector3 *argp3 ;
68400   float result;
68401
68402   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68403   arg2 = (unsigned int)jarg2;
68404   argp3 = (Dali::Vector3 *)jarg3;
68405   if (!argp3) {
68406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68407     return 0;
68408   }
68409   arg3 = *argp3;
68410   {
68411     try {
68412       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
68413     } catch (std::out_of_range& e) {
68414       {
68415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68416       };
68417     } catch (std::exception& e) {
68418       {
68419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68420       };
68421     } catch (...) {
68422       {
68423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68424       };
68425     }
68426   }
68427   jresult = result;
68428   return jresult;
68429 }
68430
68431
68432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
68433   float jresult ;
68434   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68435   float arg2 ;
68436   float result;
68437
68438   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68439   arg2 = (float)jarg2;
68440   {
68441     try {
68442       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
68443     } catch (std::out_of_range& e) {
68444       {
68445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68446       };
68447     } catch (std::exception& e) {
68448       {
68449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68450       };
68451     } catch (...) {
68452       {
68453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68454       };
68455     }
68456   }
68457   jresult = result;
68458   return jresult;
68459 }
68460
68461
68462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
68463   float jresult ;
68464   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68465   unsigned int arg2 ;
68466   float result;
68467
68468   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68469   arg2 = (unsigned int)jarg2;
68470   {
68471     try {
68472       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
68473     } catch (std::out_of_range& e) {
68474       {
68475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68476       };
68477     } catch (std::exception& e) {
68478       {
68479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68480       };
68481     } catch (...) {
68482       {
68483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68484       };
68485     }
68486   }
68487   jresult = result;
68488   return jresult;
68489 }
68490
68491
68492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
68493   void * jresult ;
68494   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68495   float arg2 ;
68496   Dali::Vector3 arg3 ;
68497   Dali::Vector3 *argp3 ;
68498   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68499
68500   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68501   arg2 = (float)jarg2;
68502   argp3 = (Dali::Vector3 *)jarg3;
68503   if (!argp3) {
68504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68505     return 0;
68506   }
68507   arg3 = *argp3;
68508   {
68509     try {
68510       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
68511     } catch (std::out_of_range& e) {
68512       {
68513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68514       };
68515     } catch (std::exception& e) {
68516       {
68517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68518       };
68519     } catch (...) {
68520       {
68521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68522       };
68523     }
68524   }
68525   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68526   return jresult;
68527 }
68528
68529
68530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
68531   float jresult ;
68532   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68533   int arg2 ;
68534   float arg3 ;
68535   Dali::Vector3 *arg4 = 0 ;
68536   float result;
68537
68538   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68539   arg2 = (int)jarg2;
68540   arg3 = (float)jarg3;
68541   arg4 = (Dali::Vector3 *)jarg4;
68542   if (!arg4) {
68543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68544     return 0;
68545   }
68546   {
68547     try {
68548       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
68549     } catch (std::out_of_range& e) {
68550       {
68551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68552       };
68553     } catch (std::exception& e) {
68554       {
68555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68556       };
68557     } catch (...) {
68558       {
68559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68560       };
68561     }
68562   }
68563   jresult = result;
68564   return jresult;
68565 }
68566
68567
68568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
68569   unsigned int jresult ;
68570   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68571   Dali::Vector3 arg2 ;
68572   Dali::Vector3 *argp2 ;
68573   unsigned int result;
68574
68575   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68576   argp2 = (Dali::Vector3 *)jarg2;
68577   if (!argp2) {
68578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68579     return 0;
68580   }
68581   arg2 = *argp2;
68582   {
68583     try {
68584       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
68585     } catch (std::out_of_range& e) {
68586       {
68587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68588       };
68589     } catch (std::exception& e) {
68590       {
68591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68592       };
68593     } catch (...) {
68594       {
68595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68596       };
68597     }
68598   }
68599   jresult = result;
68600   return jresult;
68601 }
68602
68603
68604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68605   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68606   unsigned int arg2 ;
68607   Dali::Vector3 *arg3 = 0 ;
68608   Dali::Vector3 *arg4 = 0 ;
68609
68610   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68611   arg2 = (unsigned int)jarg2;
68612   arg3 = (Dali::Vector3 *)jarg3;
68613   if (!arg3) {
68614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68615     return ;
68616   }
68617   arg4 = (Dali::Vector3 *)jarg4;
68618   if (!arg4) {
68619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68620     return ;
68621   }
68622   {
68623     try {
68624       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68625     } catch (std::out_of_range& e) {
68626       {
68627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68628       };
68629     } catch (std::exception& e) {
68630       {
68631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68632       };
68633     } catch (...) {
68634       {
68635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68636       };
68637     }
68638   }
68639 }
68640
68641
68642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
68643   void * jresult ;
68644   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68645   Dali::Degree result;
68646
68647   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68648   {
68649     try {
68650       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
68651     } catch (std::out_of_range& e) {
68652       {
68653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68654       };
68655     } catch (std::exception& e) {
68656       {
68657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68658       };
68659     } catch (...) {
68660       {
68661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68662       };
68663     }
68664   }
68665   jresult = new Dali::Degree((const Dali::Degree &)result);
68666   return jresult;
68667 }
68668
68669
68670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
68671   float jresult ;
68672   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68673   float result;
68674
68675   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68676   {
68677     try {
68678       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
68679     } catch (std::out_of_range& e) {
68680       {
68681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68682       };
68683     } catch (std::exception& e) {
68684       {
68685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68686       };
68687     } catch (...) {
68688       {
68689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68690       };
68691     }
68692   }
68693   jresult = result;
68694   return jresult;
68695 }
68696
68697
68698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
68699   float jresult ;
68700   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68701   float result;
68702
68703   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68704   {
68705     try {
68706       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
68707     } catch (std::out_of_range& e) {
68708       {
68709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68710       };
68711     } catch (std::exception& e) {
68712       {
68713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68714       };
68715     } catch (...) {
68716       {
68717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68718       };
68719     }
68720   }
68721   jresult = result;
68722   return jresult;
68723 }
68724
68725
68726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
68727   float jresult ;
68728   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68729   float result;
68730
68731   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68732   {
68733     try {
68734       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
68735     } catch (std::out_of_range& e) {
68736       {
68737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68738       };
68739     } catch (std::exception& e) {
68740       {
68741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68742       };
68743     } catch (...) {
68744       {
68745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68746       };
68747     }
68748   }
68749   jresult = result;
68750   return jresult;
68751 }
68752
68753
68754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
68755   int jresult ;
68756   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68757   int arg2 ;
68758   int arg3 ;
68759   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
68760   bool arg5 ;
68761   int result;
68762
68763   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68764   arg2 = (int)jarg2;
68765   arg3 = (int)jarg3;
68766   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
68767   arg5 = jarg5 ? true : false;
68768   {
68769     try {
68770       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
68771     } catch (std::out_of_range& e) {
68772       {
68773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68774       };
68775     } catch (std::exception& e) {
68776       {
68777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68778       };
68779     } catch (...) {
68780       {
68781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68782       };
68783     }
68784   }
68785   jresult = result;
68786   return jresult;
68787 }
68788
68789
68790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
68791   float jresult ;
68792   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68793   float result;
68794
68795   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68796   {
68797     try {
68798       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
68799     } catch (std::out_of_range& e) {
68800       {
68801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68802       };
68803     } catch (std::exception& e) {
68804       {
68805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68806       };
68807     } catch (...) {
68808       {
68809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68810       };
68811     }
68812   }
68813   jresult = result;
68814   return jresult;
68815 }
68816
68817
68818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
68819   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68820   Dali::Actor *arg2 = 0 ;
68821   int arg3 ;
68822   Dali::Vector3 *arg4 = 0 ;
68823   Dali::Actor *arg5 = 0 ;
68824
68825   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68826   arg2 = (Dali::Actor *)jarg2;
68827   if (!arg2) {
68828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
68829     return ;
68830   }
68831   arg3 = (int)jarg3;
68832   arg4 = (Dali::Vector3 *)jarg4;
68833   if (!arg4) {
68834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68835     return ;
68836   }
68837   arg5 = (Dali::Actor *)jarg5;
68838   if (!arg5) {
68839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
68840     return ;
68841   }
68842   {
68843     try {
68844       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
68845     } catch (std::out_of_range& e) {
68846       {
68847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68848       };
68849     } catch (std::exception& e) {
68850       {
68851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68852       };
68853     } catch (...) {
68854       {
68855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68856       };
68857     }
68858   }
68859 }
68860
68861
68862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
68863   void * jresult ;
68864   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68865   int arg2 ;
68866   float arg3 ;
68867   Dali::Vector3 *arg4 = 0 ;
68868   Dali::Vector3 result;
68869
68870   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68871   arg2 = (int)jarg2;
68872   arg3 = (float)jarg3;
68873   arg4 = (Dali::Vector3 *)jarg4;
68874   if (!arg4) {
68875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68876     return 0;
68877   }
68878   {
68879     try {
68880       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
68881     } catch (std::out_of_range& e) {
68882       {
68883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68884       };
68885     } catch (std::exception& e) {
68886       {
68887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68888       };
68889     } catch (...) {
68890       {
68891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68892       };
68893     }
68894   }
68895   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
68896   return jresult;
68897 }
68898
68899
68900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
68901   void * jresult ;
68902   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
68903   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
68904
68905   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
68906   {
68907     try {
68908       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
68909     } catch (std::out_of_range& e) {
68910       {
68911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68912       };
68913     } catch (std::exception& e) {
68914       {
68915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68916       };
68917     } catch (...) {
68918       {
68919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68920       };
68921     }
68922   }
68923   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
68924   return jresult;
68925 }
68926
68927
68928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
68929   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
68930
68931   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
68932   {
68933     try {
68934       delete arg1;
68935     } catch (std::out_of_range& e) {
68936       {
68937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68938       };
68939     } catch (std::exception& e) {
68940       {
68941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68942       };
68943     } catch (...) {
68944       {
68945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68946       };
68947     }
68948   }
68949 }
68950
68951
68952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
68953   unsigned int jresult ;
68954   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
68955   unsigned int result;
68956
68957   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
68958   {
68959     try {
68960       result = (unsigned int)(arg1)->GetNumberOfItems();
68961     } catch (std::out_of_range& e) {
68962       {
68963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68964       };
68965     } catch (std::exception& e) {
68966       {
68967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68968       };
68969     } catch (...) {
68970       {
68971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68972       };
68973     }
68974   }
68975   jresult = result;
68976   return jresult;
68977 }
68978
68979
68980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
68981   void * jresult ;
68982   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
68983   unsigned int arg2 ;
68984   Dali::Actor result;
68985
68986   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
68987   arg2 = (unsigned int)jarg2;
68988   {
68989     try {
68990       result = (arg1)->NewItem(arg2);
68991     } catch (std::out_of_range& e) {
68992       {
68993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68994       };
68995     } catch (std::exception& e) {
68996       {
68997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68998       };
68999     } catch (...) {
69000       {
69001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69002       };
69003     }
69004   }
69005   jresult = new Dali::Actor((const Dali::Actor &)result);
69006   return jresult;
69007 }
69008
69009
69010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69011   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69012   unsigned int arg2 ;
69013   Dali::Actor arg3 ;
69014   Dali::Actor *argp3 ;
69015
69016   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69017   arg2 = (unsigned int)jarg2;
69018   argp3 = (Dali::Actor *)jarg3;
69019   if (!argp3) {
69020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69021     return ;
69022   }
69023   arg3 = *argp3;
69024   {
69025     try {
69026       (arg1)->ItemReleased(arg2,arg3);
69027     } catch (std::out_of_range& e) {
69028       {
69029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69030       };
69031     } catch (std::exception& e) {
69032       {
69033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69034       };
69035     } catch (...) {
69036       {
69037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69038       };
69039     }
69040   }
69041 }
69042
69043
69044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69045   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69046   unsigned int arg2 ;
69047   Dali::Actor arg3 ;
69048   Dali::Actor *argp3 ;
69049
69050   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69051   arg2 = (unsigned int)jarg2;
69052   argp3 = (Dali::Actor *)jarg3;
69053   if (!argp3) {
69054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69055     return ;
69056   }
69057   arg3 = *argp3;
69058   {
69059     try {
69060       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69061     } catch (std::out_of_range& e) {
69062       {
69063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69064       };
69065     } catch (std::exception& e) {
69066       {
69067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69068       };
69069     } catch (...) {
69070       {
69071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69072       };
69073     }
69074   }
69075 }
69076
69077
69078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69079   void * jresult ;
69080   Dali::Toolkit::ItemFactory *result = 0 ;
69081
69082   {
69083     try {
69084       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69085     } catch (std::out_of_range& e) {
69086       {
69087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69088       };
69089     } catch (std::exception& e) {
69090       {
69091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69092       };
69093     } catch (...) {
69094       {
69095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69096       };
69097     }
69098   }
69099   jresult = (void *)result;
69100   return jresult;
69101 }
69102
69103
69104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_director_connect(void *objarg, SwigDirector_ItemFactory::SWIG_Callback0_t callback0, SwigDirector_ItemFactory::SWIG_Callback1_t callback1, SwigDirector_ItemFactory::SWIG_Callback2_t callback2) {
69105   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69106   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69107   if (director) {
69108     director->swig_connect_director(callback0, callback1, callback2);
69109   }
69110 }
69111
69112
69113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69114   int jresult ;
69115   int result;
69116
69117   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69118   jresult = (int)result;
69119   return jresult;
69120 }
69121
69122
69123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69124   int jresult ;
69125   int result;
69126
69127   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69128   jresult = (int)result;
69129   return jresult;
69130 }
69131
69132
69133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69134   int jresult ;
69135   int result;
69136
69137   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69138   jresult = (int)result;
69139   return jresult;
69140 }
69141
69142
69143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69144   int jresult ;
69145   int result;
69146
69147   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69148   jresult = (int)result;
69149   return jresult;
69150 }
69151
69152
69153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69154   int jresult ;
69155   int result;
69156
69157   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69158   jresult = (int)result;
69159   return jresult;
69160 }
69161
69162
69163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69164   int jresult ;
69165   int result;
69166
69167   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69168   jresult = (int)result;
69169   return jresult;
69170 }
69171
69172
69173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69174   int jresult ;
69175   int result;
69176
69177   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69178   jresult = (int)result;
69179   return jresult;
69180 }
69181
69182
69183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69184   int jresult ;
69185   int result;
69186
69187   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69188   jresult = (int)result;
69189   return jresult;
69190 }
69191
69192
69193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69194   int jresult ;
69195   int result;
69196
69197   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69198   jresult = (int)result;
69199   return jresult;
69200 }
69201
69202
69203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69204   int jresult ;
69205   int result;
69206
69207   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69208   jresult = (int)result;
69209   return jresult;
69210 }
69211
69212
69213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69214   int jresult ;
69215   int result;
69216
69217   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69218   jresult = (int)result;
69219   return jresult;
69220 }
69221
69222
69223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69224   void * jresult ;
69225   Dali::Toolkit::ItemView::Property *result = 0 ;
69226
69227   {
69228     try {
69229       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69230     } catch (std::out_of_range& e) {
69231       {
69232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69233       };
69234     } catch (std::exception& e) {
69235       {
69236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69237       };
69238     } catch (...) {
69239       {
69240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69241       };
69242     }
69243   }
69244   jresult = (void *)result;
69245   return jresult;
69246 }
69247
69248
69249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69250   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69251
69252   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69253   {
69254     try {
69255       delete arg1;
69256     } catch (std::out_of_range& e) {
69257       {
69258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69259       };
69260     } catch (std::exception& e) {
69261       {
69262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69263       };
69264     } catch (...) {
69265       {
69266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69267       };
69268     }
69269   }
69270 }
69271
69272
69273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69274   void * jresult ;
69275   Dali::Toolkit::ItemView *result = 0 ;
69276
69277   {
69278     try {
69279       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69280     } catch (std::out_of_range& e) {
69281       {
69282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69283       };
69284     } catch (std::exception& e) {
69285       {
69286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69287       };
69288     } catch (...) {
69289       {
69290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69291       };
69292     }
69293   }
69294   jresult = (void *)result;
69295   return jresult;
69296 }
69297
69298
69299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69300   void * jresult ;
69301   Dali::Toolkit::ItemView *arg1 = 0 ;
69302   Dali::Toolkit::ItemView *result = 0 ;
69303
69304   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69305   if (!arg1) {
69306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69307     return 0;
69308   }
69309   {
69310     try {
69311       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69312     } catch (std::out_of_range& e) {
69313       {
69314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69315       };
69316     } catch (std::exception& e) {
69317       {
69318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69319       };
69320     } catch (...) {
69321       {
69322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69323       };
69324     }
69325   }
69326   jresult = (void *)result;
69327   return jresult;
69328 }
69329
69330
69331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69332   void * jresult ;
69333   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69334   Dali::Toolkit::ItemView *arg2 = 0 ;
69335   Dali::Toolkit::ItemView *result = 0 ;
69336
69337   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69338   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69339   if (!arg2) {
69340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69341     return 0;
69342   }
69343   {
69344     try {
69345       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69346     } catch (std::out_of_range& e) {
69347       {
69348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69349       };
69350     } catch (std::exception& e) {
69351       {
69352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69353       };
69354     } catch (...) {
69355       {
69356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69357       };
69358     }
69359   }
69360   jresult = (void *)result;
69361   return jresult;
69362 }
69363
69364
69365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69366   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69367
69368   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69369   {
69370     try {
69371       delete arg1;
69372     } catch (std::out_of_range& e) {
69373       {
69374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69375       };
69376     } catch (std::exception& e) {
69377       {
69378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69379       };
69380     } catch (...) {
69381       {
69382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69383       };
69384     }
69385   }
69386 }
69387
69388
69389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69390   void * jresult ;
69391   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69392   Dali::Toolkit::ItemView result;
69393
69394   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69395   if (!arg1) {
69396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69397     return 0;
69398   }
69399   {
69400     try {
69401       result = Dali::Toolkit::ItemView::New(*arg1);
69402     } catch (std::out_of_range& e) {
69403       {
69404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69405       };
69406     } catch (std::exception& e) {
69407       {
69408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69409       };
69410     } catch (...) {
69411       {
69412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69413       };
69414     }
69415   }
69416   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69417   return jresult;
69418 }
69419
69420
69421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
69422   void * jresult ;
69423   Dali::BaseHandle arg1 ;
69424   Dali::BaseHandle *argp1 ;
69425   Dali::Toolkit::ItemView result;
69426
69427   argp1 = (Dali::BaseHandle *)jarg1;
69428   if (!argp1) {
69429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69430     return 0;
69431   }
69432   arg1 = *argp1;
69433   {
69434     try {
69435       result = Dali::Toolkit::ItemView::DownCast(arg1);
69436     } catch (std::out_of_range& e) {
69437       {
69438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69439       };
69440     } catch (std::exception& e) {
69441       {
69442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69443       };
69444     } catch (...) {
69445       {
69446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69447       };
69448     }
69449   }
69450   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69451   return jresult;
69452 }
69453
69454
69455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
69456   unsigned int jresult ;
69457   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69458   unsigned int result;
69459
69460   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69461   {
69462     try {
69463       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
69464     } catch (std::out_of_range& e) {
69465       {
69466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69467       };
69468     } catch (std::exception& e) {
69469       {
69470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69471       };
69472     } catch (...) {
69473       {
69474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69475       };
69476     }
69477   }
69478   jresult = result;
69479   return jresult;
69480 }
69481
69482
69483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
69484   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69485   Dali::Toolkit::ItemLayout *arg2 = 0 ;
69486
69487   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69488   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
69489   if (!arg2) {
69490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
69491     return ;
69492   }
69493   {
69494     try {
69495       (arg1)->AddLayout(*arg2);
69496     } catch (std::out_of_range& e) {
69497       {
69498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69499       };
69500     } catch (std::exception& e) {
69501       {
69502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69503       };
69504     } catch (...) {
69505       {
69506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69507       };
69508     }
69509   }
69510 }
69511
69512
69513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
69514   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69515   unsigned int arg2 ;
69516
69517   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69518   arg2 = (unsigned int)jarg2;
69519   {
69520     try {
69521       (arg1)->RemoveLayout(arg2);
69522     } catch (std::out_of_range& e) {
69523       {
69524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69525       };
69526     } catch (std::exception& e) {
69527       {
69528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69529       };
69530     } catch (...) {
69531       {
69532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69533       };
69534     }
69535   }
69536 }
69537
69538
69539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
69540   void * jresult ;
69541   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69542   unsigned int arg2 ;
69543   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69544
69545   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69546   arg2 = (unsigned int)jarg2;
69547   {
69548     try {
69549       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
69550     } catch (std::out_of_range& e) {
69551       {
69552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69553       };
69554     } catch (std::exception& e) {
69555       {
69556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69557       };
69558     } catch (...) {
69559       {
69560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69561       };
69562     }
69563   }
69564   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69565   return jresult;
69566 }
69567
69568
69569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
69570   void * jresult ;
69571   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69572   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69573
69574   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69575   {
69576     try {
69577       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
69578     } catch (std::out_of_range& e) {
69579       {
69580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69581       };
69582     } catch (std::exception& e) {
69583       {
69584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69585       };
69586     } catch (...) {
69587       {
69588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69589       };
69590     }
69591   }
69592   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69593   return jresult;
69594 }
69595
69596
69597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
69598   float jresult ;
69599   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69600   Dali::Toolkit::ItemId arg2 ;
69601   float result;
69602
69603   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69604   arg2 = (Dali::Toolkit::ItemId)jarg2;
69605   {
69606     try {
69607       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
69608     } catch (std::out_of_range& e) {
69609       {
69610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69611       };
69612     } catch (std::exception& e) {
69613       {
69614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69615       };
69616     } catch (...) {
69617       {
69618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69619       };
69620     }
69621   }
69622   jresult = result;
69623   return jresult;
69624 }
69625
69626
69627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
69628   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69629   unsigned int arg2 ;
69630   Dali::Vector3 arg3 ;
69631   float arg4 ;
69632   Dali::Vector3 *argp3 ;
69633
69634   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69635   arg2 = (unsigned int)jarg2;
69636   argp3 = (Dali::Vector3 *)jarg3;
69637   if (!argp3) {
69638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69639     return ;
69640   }
69641   arg3 = *argp3;
69642   arg4 = (float)jarg4;
69643   {
69644     try {
69645       (arg1)->ActivateLayout(arg2,arg3,arg4);
69646     } catch (std::out_of_range& e) {
69647       {
69648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69649       };
69650     } catch (std::exception& e) {
69651       {
69652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69653       };
69654     } catch (...) {
69655       {
69656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69657       };
69658     }
69659   }
69660 }
69661
69662
69663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
69664   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69665
69666   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69667   {
69668     try {
69669       (arg1)->DeactivateCurrentLayout();
69670     } catch (std::out_of_range& e) {
69671       {
69672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69673       };
69674     } catch (std::exception& e) {
69675       {
69676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69677       };
69678     } catch (...) {
69679       {
69680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69681       };
69682     }
69683   }
69684 }
69685
69686
69687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
69688   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69689   float arg2 ;
69690
69691   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69692   arg2 = (float)jarg2;
69693   {
69694     try {
69695       (arg1)->SetMinimumSwipeSpeed(arg2);
69696     } catch (std::out_of_range& e) {
69697       {
69698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69699       };
69700     } catch (std::exception& e) {
69701       {
69702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69703       };
69704     } catch (...) {
69705       {
69706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69707       };
69708     }
69709   }
69710 }
69711
69712
69713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
69714   float jresult ;
69715   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69716   float result;
69717
69718   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69719   {
69720     try {
69721       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
69722     } catch (std::out_of_range& e) {
69723       {
69724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69725       };
69726     } catch (std::exception& e) {
69727       {
69728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69729       };
69730     } catch (...) {
69731       {
69732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69733       };
69734     }
69735   }
69736   jresult = result;
69737   return jresult;
69738 }
69739
69740
69741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
69742   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69743   float arg2 ;
69744
69745   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69746   arg2 = (float)jarg2;
69747   {
69748     try {
69749       (arg1)->SetMinimumSwipeDistance(arg2);
69750     } catch (std::out_of_range& e) {
69751       {
69752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69753       };
69754     } catch (std::exception& e) {
69755       {
69756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69757       };
69758     } catch (...) {
69759       {
69760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69761       };
69762     }
69763   }
69764 }
69765
69766
69767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
69768   float jresult ;
69769   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69770   float result;
69771
69772   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69773   {
69774     try {
69775       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
69776     } catch (std::out_of_range& e) {
69777       {
69778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69779       };
69780     } catch (std::exception& e) {
69781       {
69782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69783       };
69784     } catch (...) {
69785       {
69786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69787       };
69788     }
69789   }
69790   jresult = result;
69791   return jresult;
69792 }
69793
69794
69795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
69796   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69797   float arg2 ;
69798
69799   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69800   arg2 = (float)jarg2;
69801   {
69802     try {
69803       (arg1)->SetWheelScrollDistanceStep(arg2);
69804     } catch (std::out_of_range& e) {
69805       {
69806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69807       };
69808     } catch (std::exception& e) {
69809       {
69810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69811       };
69812     } catch (...) {
69813       {
69814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69815       };
69816     }
69817   }
69818 }
69819
69820
69821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
69822   float jresult ;
69823   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69824   float result;
69825
69826   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69827   {
69828     try {
69829       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
69830     } catch (std::out_of_range& e) {
69831       {
69832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69833       };
69834     } catch (std::exception& e) {
69835       {
69836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69837       };
69838     } catch (...) {
69839       {
69840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69841       };
69842     }
69843   }
69844   jresult = result;
69845   return jresult;
69846 }
69847
69848
69849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
69850   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69851   bool arg2 ;
69852
69853   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69854   arg2 = jarg2 ? true : false;
69855   {
69856     try {
69857       (arg1)->SetAnchoring(arg2);
69858     } catch (std::out_of_range& e) {
69859       {
69860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69861       };
69862     } catch (std::exception& e) {
69863       {
69864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69865       };
69866     } catch (...) {
69867       {
69868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69869       };
69870     }
69871   }
69872 }
69873
69874
69875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
69876   unsigned int jresult ;
69877   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69878   bool result;
69879
69880   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69881   {
69882     try {
69883       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
69884     } catch (std::out_of_range& e) {
69885       {
69886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69887       };
69888     } catch (std::exception& e) {
69889       {
69890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69891       };
69892     } catch (...) {
69893       {
69894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69895       };
69896     }
69897   }
69898   jresult = result;
69899   return jresult;
69900 }
69901
69902
69903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
69904   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69905   float arg2 ;
69906
69907   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69908   arg2 = (float)jarg2;
69909   {
69910     try {
69911       (arg1)->SetAnchoringDuration(arg2);
69912     } catch (std::out_of_range& e) {
69913       {
69914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69915       };
69916     } catch (std::exception& e) {
69917       {
69918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69919       };
69920     } catch (...) {
69921       {
69922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69923       };
69924     }
69925   }
69926 }
69927
69928
69929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
69930   float jresult ;
69931   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69932   float result;
69933
69934   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69935   {
69936     try {
69937       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
69938     } catch (std::out_of_range& e) {
69939       {
69940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69941       };
69942     } catch (std::exception& e) {
69943       {
69944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (...) {
69947       {
69948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69949       };
69950     }
69951   }
69952   jresult = result;
69953   return jresult;
69954 }
69955
69956
69957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
69958   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69959   Dali::Toolkit::ItemId arg2 ;
69960   float arg3 ;
69961
69962   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69963   arg2 = (Dali::Toolkit::ItemId)jarg2;
69964   arg3 = (float)jarg3;
69965   {
69966     try {
69967       (arg1)->ScrollToItem(arg2,arg3);
69968     } catch (std::out_of_range& e) {
69969       {
69970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69971       };
69972     } catch (std::exception& e) {
69973       {
69974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69975       };
69976     } catch (...) {
69977       {
69978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69979       };
69980     }
69981   }
69982 }
69983
69984
69985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
69986   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69987   float arg2 ;
69988
69989   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69990   arg2 = (float)jarg2;
69991   {
69992     try {
69993       (arg1)->SetRefreshInterval(arg2);
69994     } catch (std::out_of_range& e) {
69995       {
69996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69997       };
69998     } catch (std::exception& e) {
69999       {
70000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70001       };
70002     } catch (...) {
70003       {
70004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70005       };
70006     }
70007   }
70008 }
70009
70010
70011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70012   float jresult ;
70013   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70014   float result;
70015
70016   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70017   {
70018     try {
70019       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70020     } catch (std::out_of_range& e) {
70021       {
70022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70023       };
70024     } catch (std::exception& e) {
70025       {
70026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70027       };
70028     } catch (...) {
70029       {
70030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70031       };
70032     }
70033   }
70034   jresult = result;
70035   return jresult;
70036 }
70037
70038
70039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70040   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70041
70042   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70043   {
70044     try {
70045       (arg1)->Refresh();
70046     } catch (std::out_of_range& e) {
70047       {
70048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70049       };
70050     } catch (std::exception& e) {
70051       {
70052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70053       };
70054     } catch (...) {
70055       {
70056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70057       };
70058     }
70059   }
70060 }
70061
70062
70063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70064   void * jresult ;
70065   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70066   Dali::Toolkit::ItemId arg2 ;
70067   Dali::Actor result;
70068
70069   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70070   arg2 = (Dali::Toolkit::ItemId)jarg2;
70071   {
70072     try {
70073       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70074     } catch (std::out_of_range& e) {
70075       {
70076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70077       };
70078     } catch (std::exception& e) {
70079       {
70080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70081       };
70082     } catch (...) {
70083       {
70084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70085       };
70086     }
70087   }
70088   jresult = new Dali::Actor((const Dali::Actor &)result);
70089   return jresult;
70090 }
70091
70092
70093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70094   unsigned int jresult ;
70095   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70096   Dali::Actor arg2 ;
70097   Dali::Actor *argp2 ;
70098   Dali::Toolkit::ItemId result;
70099
70100   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70101   argp2 = (Dali::Actor *)jarg2;
70102   if (!argp2) {
70103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70104     return 0;
70105   }
70106   arg2 = *argp2;
70107   {
70108     try {
70109       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70110     } catch (std::out_of_range& e) {
70111       {
70112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70113       };
70114     } catch (std::exception& e) {
70115       {
70116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70117       };
70118     } catch (...) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70121       };
70122     }
70123   }
70124   jresult = result;
70125   return jresult;
70126 }
70127
70128
70129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70130   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70131   Dali::Toolkit::Item arg2 ;
70132   float arg3 ;
70133   Dali::Toolkit::Item *argp2 ;
70134
70135   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70136   argp2 = (Dali::Toolkit::Item *)jarg2;
70137   if (!argp2) {
70138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70139     return ;
70140   }
70141   arg2 = *argp2;
70142   arg3 = (float)jarg3;
70143   {
70144     try {
70145       (arg1)->InsertItem(arg2,arg3);
70146     } catch (std::out_of_range& e) {
70147       {
70148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70149       };
70150     } catch (std::exception& e) {
70151       {
70152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70153       };
70154     } catch (...) {
70155       {
70156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70157       };
70158     }
70159   }
70160 }
70161
70162
70163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70164   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70165   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70166   float arg3 ;
70167
70168   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70169   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70170   if (!arg2) {
70171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70172     return ;
70173   }
70174   arg3 = (float)jarg3;
70175   {
70176     try {
70177       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70178     } catch (std::out_of_range& e) {
70179       {
70180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70181       };
70182     } catch (std::exception& e) {
70183       {
70184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70185       };
70186     } catch (...) {
70187       {
70188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70189       };
70190     }
70191   }
70192 }
70193
70194
70195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70196   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70197   Dali::Toolkit::ItemId arg2 ;
70198   float arg3 ;
70199
70200   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70201   arg2 = (Dali::Toolkit::ItemId)jarg2;
70202   arg3 = (float)jarg3;
70203   {
70204     try {
70205       (arg1)->RemoveItem(arg2,arg3);
70206     } catch (std::out_of_range& e) {
70207       {
70208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70209       };
70210     } catch (std::exception& e) {
70211       {
70212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70213       };
70214     } catch (...) {
70215       {
70216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70217       };
70218     }
70219   }
70220 }
70221
70222
70223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70224   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70225   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70226   float arg3 ;
70227
70228   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70229   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70230   if (!arg2) {
70231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70232     return ;
70233   }
70234   arg3 = (float)jarg3;
70235   {
70236     try {
70237       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70238     } catch (std::out_of_range& e) {
70239       {
70240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70241       };
70242     } catch (std::exception& e) {
70243       {
70244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70245       };
70246     } catch (...) {
70247       {
70248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70249       };
70250     }
70251   }
70252 }
70253
70254
70255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70256   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70257   Dali::Toolkit::Item arg2 ;
70258   float arg3 ;
70259   Dali::Toolkit::Item *argp2 ;
70260
70261   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70262   argp2 = (Dali::Toolkit::Item *)jarg2;
70263   if (!argp2) {
70264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70265     return ;
70266   }
70267   arg2 = *argp2;
70268   arg3 = (float)jarg3;
70269   {
70270     try {
70271       (arg1)->ReplaceItem(arg2,arg3);
70272     } catch (std::out_of_range& e) {
70273       {
70274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70275       };
70276     } catch (std::exception& e) {
70277       {
70278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70279       };
70280     } catch (...) {
70281       {
70282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70283       };
70284     }
70285   }
70286 }
70287
70288
70289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70290   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70291   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70292   float arg3 ;
70293
70294   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70295   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70296   if (!arg2) {
70297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70298     return ;
70299   }
70300   arg3 = (float)jarg3;
70301   {
70302     try {
70303       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70304     } catch (std::out_of_range& e) {
70305       {
70306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70307       };
70308     } catch (std::exception& e) {
70309       {
70310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70311       };
70312     } catch (...) {
70313       {
70314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70315       };
70316     }
70317   }
70318 }
70319
70320
70321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70322   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70323   Dali::Vector3 *arg2 = 0 ;
70324
70325   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70326   arg2 = (Dali::Vector3 *)jarg2;
70327   if (!arg2) {
70328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70329     return ;
70330   }
70331   {
70332     try {
70333       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70334     } catch (std::out_of_range& e) {
70335       {
70336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70337       };
70338     } catch (std::exception& e) {
70339       {
70340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70341       };
70342     } catch (...) {
70343       {
70344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70345       };
70346     }
70347   }
70348 }
70349
70350
70351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70352   void * jresult ;
70353   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70354   Dali::Vector3 result;
70355
70356   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70357   {
70358     try {
70359       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70360     } catch (std::out_of_range& e) {
70361       {
70362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70363       };
70364     } catch (std::exception& e) {
70365       {
70366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70367       };
70368     } catch (...) {
70369       {
70370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70371       };
70372     }
70373   }
70374   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70375   return jresult;
70376 }
70377
70378
70379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70380   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70381   Dali::Vector3 *arg2 = 0 ;
70382
70383   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70384   arg2 = (Dali::Vector3 *)jarg2;
70385   if (!arg2) {
70386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70387     return ;
70388   }
70389   {
70390     try {
70391       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70392     } catch (std::out_of_range& e) {
70393       {
70394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70395       };
70396     } catch (std::exception& e) {
70397       {
70398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70399       };
70400     } catch (...) {
70401       {
70402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70403       };
70404     }
70405   }
70406 }
70407
70408
70409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
70410   void * jresult ;
70411   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70412   Dali::Vector3 result;
70413
70414   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70415   {
70416     try {
70417       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
70418     } catch (std::out_of_range& e) {
70419       {
70420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70421       };
70422     } catch (std::exception& e) {
70423       {
70424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70425       };
70426     } catch (...) {
70427       {
70428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70429       };
70430     }
70431   }
70432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70433   return jresult;
70434 }
70435
70436
70437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
70438   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70439   Dali::Toolkit::ItemRange *arg2 = 0 ;
70440
70441   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70442   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70443   if (!arg2) {
70444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
70445     return ;
70446   }
70447   {
70448     try {
70449       (arg1)->GetItemsRange(*arg2);
70450     } catch (std::out_of_range& e) {
70451       {
70452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70453       };
70454     } catch (std::exception& e) {
70455       {
70456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70457       };
70458     } catch (...) {
70459       {
70460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70461       };
70462     }
70463   }
70464 }
70465
70466
70467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
70468   void * jresult ;
70469   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70470   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
70471
70472   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70473   {
70474     try {
70475       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
70476     } catch (std::out_of_range& e) {
70477       {
70478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70479       };
70480     } catch (std::exception& e) {
70481       {
70482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70483       };
70484     } catch (...) {
70485       {
70486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70487       };
70488     }
70489   }
70490   jresult = (void *)result;
70491   return jresult;
70492 }
70493
70494
70495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
70496   Dali::Vector3 *arg1 = 0 ;
70497   PropertyInputContainer *arg2 = 0 ;
70498
70499   arg1 = (Dali::Vector3 *)jarg1;
70500   if (!arg1) {
70501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70502     return ;
70503   }
70504   arg2 = (PropertyInputContainer *)jarg2;
70505   if (!arg2) {
70506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70507     return ;
70508   }
70509   {
70510     try {
70511       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70512     } catch (std::out_of_range& e) {
70513       {
70514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70515       };
70516     } catch (std::exception& e) {
70517       {
70518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70519       };
70520     } catch (...) {
70521       {
70522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70523       };
70524     }
70525   }
70526 }
70527
70528
70529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
70530   Dali::Vector3 *arg1 = 0 ;
70531   PropertyInputContainer *arg2 = 0 ;
70532
70533   arg1 = (Dali::Vector3 *)jarg1;
70534   if (!arg1) {
70535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70536     return ;
70537   }
70538   arg2 = (PropertyInputContainer *)jarg2;
70539   if (!arg2) {
70540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70541     return ;
70542   }
70543   {
70544     try {
70545       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70546     } catch (std::out_of_range& e) {
70547       {
70548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70549       };
70550     } catch (std::exception& e) {
70551       {
70552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70553       };
70554     } catch (...) {
70555       {
70556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70557       };
70558     }
70559   }
70560 }
70561
70562
70563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
70564   void * jresult ;
70565   Dali::Toolkit::ScrollViewEffect *result = 0 ;
70566
70567   {
70568     try {
70569       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
70570     } catch (std::out_of_range& e) {
70571       {
70572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70573       };
70574     } catch (std::exception& e) {
70575       {
70576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70577       };
70578     } catch (...) {
70579       {
70580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70581       };
70582     }
70583   }
70584   jresult = (void *)result;
70585   return jresult;
70586 }
70587
70588
70589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
70590   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
70591
70592   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
70593   {
70594     try {
70595       delete arg1;
70596     } catch (std::out_of_range& e) {
70597       {
70598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70599       };
70600     } catch (std::exception& e) {
70601       {
70602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70603       };
70604     } catch (...) {
70605       {
70606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70607       };
70608     }
70609   }
70610 }
70611
70612
70613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
70614   void * jresult ;
70615   Dali::Path arg1 ;
70616   Dali::Vector3 *arg2 = 0 ;
70617   Dali::Property::Index arg3 ;
70618   Dali::Vector3 *arg4 = 0 ;
70619   unsigned int arg5 ;
70620   Dali::Path *argp1 ;
70621   Dali::Toolkit::ScrollViewPagePathEffect result;
70622
70623   argp1 = (Dali::Path *)jarg1;
70624   if (!argp1) {
70625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
70626     return 0;
70627   }
70628   arg1 = *argp1;
70629   arg2 = (Dali::Vector3 *)jarg2;
70630   if (!arg2) {
70631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70632     return 0;
70633   }
70634   arg3 = (Dali::Property::Index)jarg3;
70635   arg4 = (Dali::Vector3 *)jarg4;
70636   if (!arg4) {
70637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70638     return 0;
70639   }
70640   arg5 = (unsigned int)jarg5;
70641   {
70642     try {
70643       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
70644     } catch (std::out_of_range& e) {
70645       {
70646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70647       };
70648     } catch (std::exception& e) {
70649       {
70650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70651       };
70652     } catch (...) {
70653       {
70654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70655       };
70656     }
70657   }
70658   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
70659   return jresult;
70660 }
70661
70662
70663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
70664   void * jresult ;
70665   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
70666
70667   {
70668     try {
70669       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
70670     } catch (std::out_of_range& e) {
70671       {
70672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70673       };
70674     } catch (std::exception& e) {
70675       {
70676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70677       };
70678     } catch (...) {
70679       {
70680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70681       };
70682     }
70683   }
70684   jresult = (void *)result;
70685   return jresult;
70686 }
70687
70688
70689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
70690   void * jresult ;
70691   Dali::BaseHandle arg1 ;
70692   Dali::BaseHandle *argp1 ;
70693   Dali::Toolkit::ScrollViewPagePathEffect result;
70694
70695   argp1 = (Dali::BaseHandle *)jarg1;
70696   if (!argp1) {
70697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70698     return 0;
70699   }
70700   arg1 = *argp1;
70701   {
70702     try {
70703       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
70704     } catch (std::out_of_range& e) {
70705       {
70706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70707       };
70708     } catch (std::exception& e) {
70709       {
70710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70711       };
70712     } catch (...) {
70713       {
70714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70715       };
70716     }
70717   }
70718   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
70719   return jresult;
70720 }
70721
70722
70723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
70724   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
70725   Dali::Actor arg2 ;
70726   unsigned int arg3 ;
70727   Dali::Actor *argp2 ;
70728
70729   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
70730   argp2 = (Dali::Actor *)jarg2;
70731   if (!argp2) {
70732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70733     return ;
70734   }
70735   arg2 = *argp2;
70736   arg3 = (unsigned int)jarg3;
70737   {
70738     try {
70739       (arg1)->ApplyToPage(arg2,arg3);
70740     } catch (std::out_of_range& e) {
70741       {
70742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70743       };
70744     } catch (std::exception& e) {
70745       {
70746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70747       };
70748     } catch (...) {
70749       {
70750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70751       };
70752     }
70753   }
70754 }
70755
70756
70757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
70758   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
70759
70760   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
70761   {
70762     try {
70763       delete arg1;
70764     } catch (std::out_of_range& e) {
70765       {
70766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70767       };
70768     } catch (std::exception& e) {
70769       {
70770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70771       };
70772     } catch (...) {
70773       {
70774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70775       };
70776     }
70777   }
70778 }
70779
70780
70781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
70782   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70783   Dali::Toolkit::ClampState arg2 ;
70784
70785   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70786   arg2 = (Dali::Toolkit::ClampState)jarg2;
70787   if (arg1) (arg1)->x = arg2;
70788 }
70789
70790
70791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
70792   int jresult ;
70793   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70794   Dali::Toolkit::ClampState result;
70795
70796   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70797   result = (Dali::Toolkit::ClampState) ((arg1)->x);
70798   jresult = (int)result;
70799   return jresult;
70800 }
70801
70802
70803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
70804   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70805   Dali::Toolkit::ClampState arg2 ;
70806
70807   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70808   arg2 = (Dali::Toolkit::ClampState)jarg2;
70809   if (arg1) (arg1)->y = arg2;
70810 }
70811
70812
70813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
70814   int jresult ;
70815   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70816   Dali::Toolkit::ClampState result;
70817
70818   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70819   result = (Dali::Toolkit::ClampState) ((arg1)->y);
70820   jresult = (int)result;
70821   return jresult;
70822 }
70823
70824
70825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
70826   void * jresult ;
70827   Dali::Toolkit::ClampState2D *result = 0 ;
70828
70829   {
70830     try {
70831       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
70832     } catch (std::out_of_range& e) {
70833       {
70834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70835       };
70836     } catch (std::exception& e) {
70837       {
70838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70839       };
70840     } catch (...) {
70841       {
70842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70843       };
70844     }
70845   }
70846   jresult = (void *)result;
70847   return jresult;
70848 }
70849
70850
70851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
70852   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70853
70854   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70855   {
70856     try {
70857       delete arg1;
70858     } catch (std::out_of_range& e) {
70859       {
70860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70861       };
70862     } catch (std::exception& e) {
70863       {
70864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70865       };
70866     } catch (...) {
70867       {
70868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70869       };
70870     }
70871   }
70872 }
70873
70874
70875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
70876   void * jresult ;
70877   float arg1 ;
70878   float arg2 ;
70879   bool arg3 ;
70880   Dali::Toolkit::RulerDomain *result = 0 ;
70881
70882   arg1 = (float)jarg1;
70883   arg2 = (float)jarg2;
70884   arg3 = jarg3 ? true : false;
70885   {
70886     try {
70887       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
70888     } catch (std::out_of_range& e) {
70889       {
70890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70891       };
70892     } catch (std::exception& e) {
70893       {
70894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70895       };
70896     } catch (...) {
70897       {
70898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70899       };
70900     }
70901   }
70902   jresult = (void *)result;
70903   return jresult;
70904 }
70905
70906
70907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
70908   void * jresult ;
70909   float arg1 ;
70910   float arg2 ;
70911   Dali::Toolkit::RulerDomain *result = 0 ;
70912
70913   arg1 = (float)jarg1;
70914   arg2 = (float)jarg2;
70915   {
70916     try {
70917       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
70918     } catch (std::out_of_range& e) {
70919       {
70920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70921       };
70922     } catch (std::exception& e) {
70923       {
70924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70925       };
70926     } catch (...) {
70927       {
70928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70929       };
70930     }
70931   }
70932   jresult = (void *)result;
70933   return jresult;
70934 }
70935
70936
70937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
70938   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70939   float arg2 ;
70940
70941   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70942   arg2 = (float)jarg2;
70943   if (arg1) (arg1)->min = arg2;
70944 }
70945
70946
70947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
70948   float jresult ;
70949   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70950   float result;
70951
70952   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70953   result = (float) ((arg1)->min);
70954   jresult = result;
70955   return jresult;
70956 }
70957
70958
70959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
70960   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70961   float arg2 ;
70962
70963   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70964   arg2 = (float)jarg2;
70965   if (arg1) (arg1)->max = arg2;
70966 }
70967
70968
70969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
70970   float jresult ;
70971   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70972   float result;
70973
70974   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70975   result = (float) ((arg1)->max);
70976   jresult = result;
70977   return jresult;
70978 }
70979
70980
70981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
70982   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70983   bool arg2 ;
70984
70985   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70986   arg2 = jarg2 ? true : false;
70987   if (arg1) (arg1)->enabled = arg2;
70988 }
70989
70990
70991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
70992   unsigned int jresult ;
70993   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70994   bool result;
70995
70996   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70997   result = (bool) ((arg1)->enabled);
70998   jresult = result;
70999   return jresult;
71000 }
71001
71002
71003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71004   float jresult ;
71005   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71006   float arg2 ;
71007   float arg3 ;
71008   float arg4 ;
71009   float result;
71010
71011   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71012   arg2 = (float)jarg2;
71013   arg3 = (float)jarg3;
71014   arg4 = (float)jarg4;
71015   {
71016     try {
71017       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71018     } catch (std::out_of_range& e) {
71019       {
71020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71021       };
71022     } catch (std::exception& e) {
71023       {
71024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71025       };
71026     } catch (...) {
71027       {
71028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71029       };
71030     }
71031   }
71032   jresult = result;
71033   return jresult;
71034 }
71035
71036
71037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71038   float jresult ;
71039   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71040   float arg2 ;
71041   float arg3 ;
71042   float result;
71043
71044   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71045   arg2 = (float)jarg2;
71046   arg3 = (float)jarg3;
71047   {
71048     try {
71049       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71050     } catch (std::out_of_range& e) {
71051       {
71052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71053       };
71054     } catch (std::exception& e) {
71055       {
71056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71057       };
71058     } catch (...) {
71059       {
71060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71061       };
71062     }
71063   }
71064   jresult = result;
71065   return jresult;
71066 }
71067
71068
71069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71070   float jresult ;
71071   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71072   float arg2 ;
71073   float result;
71074
71075   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71076   arg2 = (float)jarg2;
71077   {
71078     try {
71079       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71080     } catch (std::out_of_range& e) {
71081       {
71082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71083       };
71084     } catch (std::exception& e) {
71085       {
71086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71087       };
71088     } catch (...) {
71089       {
71090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71091       };
71092     }
71093   }
71094   jresult = result;
71095   return jresult;
71096 }
71097
71098
71099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71100   float jresult ;
71101   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71102   float arg2 ;
71103   float arg3 ;
71104   float arg4 ;
71105   Dali::Toolkit::ClampState *arg5 = 0 ;
71106   float result;
71107
71108   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71109   arg2 = (float)jarg2;
71110   arg3 = (float)jarg3;
71111   arg4 = (float)jarg4;
71112   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71113   if (!arg5) {
71114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71115     return 0;
71116   }
71117   {
71118     try {
71119       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71120     } catch (std::out_of_range& e) {
71121       {
71122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71123       };
71124     } catch (std::exception& e) {
71125       {
71126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71127       };
71128     } catch (...) {
71129       {
71130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71131       };
71132     }
71133   }
71134   jresult = result;
71135   return jresult;
71136 }
71137
71138
71139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71140   float jresult ;
71141   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71142   float result;
71143
71144   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71145   {
71146     try {
71147       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71148     } catch (std::out_of_range& e) {
71149       {
71150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71151       };
71152     } catch (std::exception& e) {
71153       {
71154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71155       };
71156     } catch (...) {
71157       {
71158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71159       };
71160     }
71161   }
71162   jresult = result;
71163   return jresult;
71164 }
71165
71166
71167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71168   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71169
71170   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71171   {
71172     try {
71173       delete arg1;
71174     } catch (std::out_of_range& e) {
71175       {
71176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71177       };
71178     } catch (std::exception& e) {
71179       {
71180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71181       };
71182     } catch (...) {
71183       {
71184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71185       };
71186     }
71187   }
71188 }
71189
71190
71191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71192   float jresult ;
71193   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71194   float arg2 ;
71195   float arg3 ;
71196   float result;
71197
71198   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71199   arg2 = (float)jarg2;
71200   arg3 = (float)jarg3;
71201   {
71202     try {
71203       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71204     } catch (std::out_of_range& e) {
71205       {
71206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71207       };
71208     } catch (std::exception& e) {
71209       {
71210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71211       };
71212     } catch (...) {
71213       {
71214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71215       };
71216     }
71217   }
71218   jresult = result;
71219   return jresult;
71220 }
71221
71222
71223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71224   float jresult ;
71225   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71226   float arg2 ;
71227   float result;
71228
71229   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71230   arg2 = (float)jarg2;
71231   {
71232     try {
71233       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71234     } catch (std::out_of_range& e) {
71235       {
71236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71237       };
71238     } catch (std::exception& e) {
71239       {
71240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71241       };
71242     } catch (...) {
71243       {
71244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71245       };
71246     }
71247   }
71248   jresult = result;
71249   return jresult;
71250 }
71251
71252
71253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71254   float jresult ;
71255   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71256   unsigned int arg2 ;
71257   unsigned int *arg3 = 0 ;
71258   bool arg4 ;
71259   float result;
71260
71261   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71262   arg2 = (unsigned int)jarg2;
71263   arg3 = (unsigned int *)jarg3;
71264   arg4 = jarg4 ? true : false;
71265   {
71266     try {
71267       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71268     } catch (std::out_of_range& e) {
71269       {
71270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71271       };
71272     } catch (std::exception& e) {
71273       {
71274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71275       };
71276     } catch (...) {
71277       {
71278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71279       };
71280     }
71281   }
71282   jresult = result;
71283   return jresult;
71284 }
71285
71286
71287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71288   unsigned int jresult ;
71289   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71290   float arg2 ;
71291   bool arg3 ;
71292   unsigned int result;
71293
71294   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71295   arg2 = (float)jarg2;
71296   arg3 = jarg3 ? true : false;
71297   {
71298     try {
71299       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71300     } catch (std::out_of_range& e) {
71301       {
71302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71303       };
71304     } catch (std::exception& e) {
71305       {
71306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71307       };
71308     } catch (...) {
71309       {
71310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71311       };
71312     }
71313   }
71314   jresult = result;
71315   return jresult;
71316 }
71317
71318
71319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71320   unsigned int jresult ;
71321   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71322   unsigned int result;
71323
71324   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71325   {
71326     try {
71327       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71328     } catch (std::out_of_range& e) {
71329       {
71330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71331       };
71332     } catch (std::exception& e) {
71333       {
71334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71335       };
71336     } catch (...) {
71337       {
71338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71339       };
71340     }
71341   }
71342   jresult = result;
71343   return jresult;
71344 }
71345
71346
71347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71348   int jresult ;
71349   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71350   Dali::Toolkit::Ruler::RulerType result;
71351
71352   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71353   {
71354     try {
71355       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
71356     } catch (std::out_of_range& e) {
71357       {
71358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71359       };
71360     } catch (std::exception& e) {
71361       {
71362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71363       };
71364     } catch (...) {
71365       {
71366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71367       };
71368     }
71369   }
71370   jresult = (int)result;
71371   return jresult;
71372 }
71373
71374
71375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71376   unsigned int jresult ;
71377   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71378   bool result;
71379
71380   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71381   {
71382     try {
71383       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71384     } catch (std::out_of_range& e) {
71385       {
71386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71387       };
71388     } catch (std::exception& e) {
71389       {
71390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71391       };
71392     } catch (...) {
71393       {
71394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71395       };
71396     }
71397   }
71398   jresult = result;
71399   return jresult;
71400 }
71401
71402
71403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
71404   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71405
71406   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71407   {
71408     try {
71409       (arg1)->Enable();
71410     } catch (std::out_of_range& e) {
71411       {
71412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71413       };
71414     } catch (std::exception& e) {
71415       {
71416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71417       };
71418     } catch (...) {
71419       {
71420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71421       };
71422     }
71423   }
71424 }
71425
71426
71427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
71428   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71429
71430   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71431   {
71432     try {
71433       (arg1)->Disable();
71434     } catch (std::out_of_range& e) {
71435       {
71436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71437       };
71438     } catch (std::exception& e) {
71439       {
71440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71441       };
71442     } catch (...) {
71443       {
71444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71445       };
71446     }
71447   }
71448 }
71449
71450
71451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
71452   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71453   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
71454   Dali::Toolkit::RulerDomain *argp2 ;
71455
71456   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71457   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
71458   if (!argp2) {
71459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
71460     return ;
71461   }
71462   arg2 = *argp2;
71463   {
71464     try {
71465       (arg1)->SetDomain(arg2);
71466     } catch (std::out_of_range& e) {
71467       {
71468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71469       };
71470     } catch (std::exception& e) {
71471       {
71472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71473       };
71474     } catch (...) {
71475       {
71476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71477       };
71478     }
71479   }
71480 }
71481
71482
71483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
71484   void * jresult ;
71485   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71486   Dali::Toolkit::RulerDomain *result = 0 ;
71487
71488   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71489   {
71490     try {
71491       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
71492     } catch (std::out_of_range& e) {
71493       {
71494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71495       };
71496     } catch (std::exception& e) {
71497       {
71498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71499       };
71500     } catch (...) {
71501       {
71502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71503       };
71504     }
71505   }
71506   jresult = (void *)result;
71507   return jresult;
71508 }
71509
71510
71511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
71512   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71513
71514   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71515   {
71516     try {
71517       (arg1)->DisableDomain();
71518     } catch (std::out_of_range& e) {
71519       {
71520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71521       };
71522     } catch (std::exception& e) {
71523       {
71524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71525       };
71526     } catch (...) {
71527       {
71528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71529       };
71530     }
71531   }
71532 }
71533
71534
71535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71536   float jresult ;
71537   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71538   float arg2 ;
71539   float arg3 ;
71540   float arg4 ;
71541   float result;
71542
71543   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71544   arg2 = (float)jarg2;
71545   arg3 = (float)jarg3;
71546   arg4 = (float)jarg4;
71547   {
71548     try {
71549       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
71550     } catch (std::out_of_range& e) {
71551       {
71552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71553       };
71554     } catch (std::exception& e) {
71555       {
71556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71557       };
71558     } catch (...) {
71559       {
71560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71561       };
71562     }
71563   }
71564   jresult = result;
71565   return jresult;
71566 }
71567
71568
71569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71570   float jresult ;
71571   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71572   float arg2 ;
71573   float arg3 ;
71574   float result;
71575
71576   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71577   arg2 = (float)jarg2;
71578   arg3 = (float)jarg3;
71579   {
71580     try {
71581       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
71582     } catch (std::out_of_range& e) {
71583       {
71584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71585       };
71586     } catch (std::exception& e) {
71587       {
71588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71589       };
71590     } catch (...) {
71591       {
71592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71593       };
71594     }
71595   }
71596   jresult = result;
71597   return jresult;
71598 }
71599
71600
71601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
71602   float jresult ;
71603   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71604   float arg2 ;
71605   float result;
71606
71607   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71608   arg2 = (float)jarg2;
71609   {
71610     try {
71611       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
71612     } catch (std::out_of_range& e) {
71613       {
71614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71615       };
71616     } catch (std::exception& e) {
71617       {
71618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71619       };
71620     } catch (...) {
71621       {
71622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71623       };
71624     }
71625   }
71626   jresult = result;
71627   return jresult;
71628 }
71629
71630
71631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71632   float jresult ;
71633   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71634   float arg2 ;
71635   float arg3 ;
71636   float arg4 ;
71637   Dali::Toolkit::ClampState *arg5 = 0 ;
71638   float result;
71639
71640   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71641   arg2 = (float)jarg2;
71642   arg3 = (float)jarg3;
71643   arg4 = (float)jarg4;
71644   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71645   if (!arg5) {
71646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71647     return 0;
71648   }
71649   {
71650     try {
71651       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71652     } catch (std::out_of_range& e) {
71653       {
71654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71655       };
71656     } catch (std::exception& e) {
71657       {
71658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71659       };
71660     } catch (...) {
71661       {
71662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71663       };
71664     }
71665   }
71666   jresult = result;
71667   return jresult;
71668 }
71669
71670
71671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
71672   float jresult ;
71673   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71674   float arg2 ;
71675   float arg3 ;
71676   float arg4 ;
71677   float arg5 ;
71678   float result;
71679
71680   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71681   arg2 = (float)jarg2;
71682   arg3 = (float)jarg3;
71683   arg4 = (float)jarg4;
71684   arg5 = (float)jarg5;
71685   {
71686     try {
71687       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
71688     } catch (std::out_of_range& e) {
71689       {
71690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71691       };
71692     } catch (std::exception& e) {
71693       {
71694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71695       };
71696     } catch (...) {
71697       {
71698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71699       };
71700     }
71701   }
71702   jresult = result;
71703   return jresult;
71704 }
71705
71706
71707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
71708   float jresult ;
71709   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71710   float arg2 ;
71711   float arg3 ;
71712   float arg4 ;
71713   float result;
71714
71715   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71716   arg2 = (float)jarg2;
71717   arg3 = (float)jarg3;
71718   arg4 = (float)jarg4;
71719   {
71720     try {
71721       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
71722     } catch (std::out_of_range& e) {
71723       {
71724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71725       };
71726     } catch (std::exception& e) {
71727       {
71728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71729       };
71730     } catch (...) {
71731       {
71732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71733       };
71734     }
71735   }
71736   jresult = result;
71737   return jresult;
71738 }
71739
71740
71741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
71742   float jresult ;
71743   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71744   float arg2 ;
71745   float arg3 ;
71746   float result;
71747
71748   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71749   arg2 = (float)jarg2;
71750   arg3 = (float)jarg3;
71751   {
71752     try {
71753       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
71754     } catch (std::out_of_range& e) {
71755       {
71756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71757       };
71758     } catch (std::exception& e) {
71759       {
71760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71761       };
71762     } catch (...) {
71763       {
71764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71765       };
71766     }
71767   }
71768   jresult = result;
71769   return jresult;
71770 }
71771
71772
71773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
71774   float jresult ;
71775   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71776   float arg2 ;
71777   float result;
71778
71779   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71780   arg2 = (float)jarg2;
71781   {
71782     try {
71783       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
71784     } catch (std::out_of_range& e) {
71785       {
71786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71787       };
71788     } catch (std::exception& e) {
71789       {
71790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71791       };
71792     } catch (...) {
71793       {
71794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71795       };
71796     }
71797   }
71798   jresult = result;
71799   return jresult;
71800 }
71801
71802
71803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
71804   float jresult ;
71805   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71806   float arg2 ;
71807   float arg3 ;
71808   float arg4 ;
71809   float arg5 ;
71810   Dali::Toolkit::ClampState *arg6 = 0 ;
71811   float result;
71812
71813   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71814   arg2 = (float)jarg2;
71815   arg3 = (float)jarg3;
71816   arg4 = (float)jarg4;
71817   arg5 = (float)jarg5;
71818   arg6 = (Dali::Toolkit::ClampState *)jarg6;
71819   if (!arg6) {
71820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71821     return 0;
71822   }
71823   {
71824     try {
71825       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
71826     } catch (std::out_of_range& e) {
71827       {
71828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71829       };
71830     } catch (std::exception& e) {
71831       {
71832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71833       };
71834     } catch (...) {
71835       {
71836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71837       };
71838     }
71839   }
71840   jresult = result;
71841   return jresult;
71842 }
71843
71844
71845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
71846   void * jresult ;
71847   Dali::Toolkit::DefaultRuler *result = 0 ;
71848
71849   {
71850     try {
71851       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
71852     } catch (std::out_of_range& e) {
71853       {
71854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71855       };
71856     } catch (std::exception& e) {
71857       {
71858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71859       };
71860     } catch (...) {
71861       {
71862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71863       };
71864     }
71865   }
71866   jresult = (void *)result;
71867   return jresult;
71868 }
71869
71870
71871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
71872   float jresult ;
71873   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
71874   float arg2 ;
71875   float arg3 ;
71876   float result;
71877
71878   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
71879   arg2 = (float)jarg2;
71880   arg3 = (float)jarg3;
71881   {
71882     try {
71883       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
71884     } catch (std::out_of_range& e) {
71885       {
71886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71887       };
71888     } catch (std::exception& e) {
71889       {
71890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71891       };
71892     } catch (...) {
71893       {
71894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71895       };
71896     }
71897   }
71898   jresult = result;
71899   return jresult;
71900 }
71901
71902
71903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71904   float jresult ;
71905   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
71906   unsigned int arg2 ;
71907   unsigned int *arg3 = 0 ;
71908   bool arg4 ;
71909   float result;
71910
71911   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
71912   arg2 = (unsigned int)jarg2;
71913   arg3 = (unsigned int *)jarg3;
71914   arg4 = jarg4 ? true : false;
71915   {
71916     try {
71917       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71918     } catch (std::out_of_range& e) {
71919       {
71920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71921       };
71922     } catch (std::exception& e) {
71923       {
71924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71925       };
71926     } catch (...) {
71927       {
71928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71929       };
71930     }
71931   }
71932   jresult = result;
71933   return jresult;
71934 }
71935
71936
71937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71938   unsigned int jresult ;
71939   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
71940   float arg2 ;
71941   bool arg3 ;
71942   unsigned int result;
71943
71944   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
71945   arg2 = (float)jarg2;
71946   arg3 = jarg3 ? true : false;
71947   {
71948     try {
71949       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
71950     } catch (std::out_of_range& e) {
71951       {
71952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71953       };
71954     } catch (std::exception& e) {
71955       {
71956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71957       };
71958     } catch (...) {
71959       {
71960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71961       };
71962     }
71963   }
71964   jresult = result;
71965   return jresult;
71966 }
71967
71968
71969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
71970   unsigned int jresult ;
71971   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
71972   unsigned int result;
71973
71974   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
71975   {
71976     try {
71977       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
71978     } catch (std::out_of_range& e) {
71979       {
71980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71981       };
71982     } catch (std::exception& e) {
71983       {
71984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71985       };
71986     } catch (...) {
71987       {
71988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71989       };
71990     }
71991   }
71992   jresult = result;
71993   return jresult;
71994 }
71995
71996
71997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
71998   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
71999
72000   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72001   {
72002     try {
72003       delete arg1;
72004     } catch (std::out_of_range& e) {
72005       {
72006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72007       };
72008     } catch (std::exception& e) {
72009       {
72010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72011       };
72012     } catch (...) {
72013       {
72014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72015       };
72016     }
72017   }
72018 }
72019
72020
72021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72022   void * jresult ;
72023   float arg1 ;
72024   Dali::Toolkit::FixedRuler *result = 0 ;
72025
72026   arg1 = (float)jarg1;
72027   {
72028     try {
72029       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72030     } catch (std::out_of_range& e) {
72031       {
72032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72033       };
72034     } catch (std::exception& e) {
72035       {
72036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72037       };
72038     } catch (...) {
72039       {
72040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72041       };
72042     }
72043   }
72044   jresult = (void *)result;
72045   return jresult;
72046 }
72047
72048
72049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72050   void * jresult ;
72051   Dali::Toolkit::FixedRuler *result = 0 ;
72052
72053   {
72054     try {
72055       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72056     } catch (std::out_of_range& e) {
72057       {
72058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72059       };
72060     } catch (std::exception& e) {
72061       {
72062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72063       };
72064     } catch (...) {
72065       {
72066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72067       };
72068     }
72069   }
72070   jresult = (void *)result;
72071   return jresult;
72072 }
72073
72074
72075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72076   float jresult ;
72077   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72078   float arg2 ;
72079   float arg3 ;
72080   float result;
72081
72082   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72083   arg2 = (float)jarg2;
72084   arg3 = (float)jarg3;
72085   {
72086     try {
72087       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72088     } catch (std::out_of_range& e) {
72089       {
72090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72091       };
72092     } catch (std::exception& e) {
72093       {
72094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72095       };
72096     } catch (...) {
72097       {
72098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72099       };
72100     }
72101   }
72102   jresult = result;
72103   return jresult;
72104 }
72105
72106
72107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72108   float jresult ;
72109   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72110   unsigned int arg2 ;
72111   unsigned int *arg3 = 0 ;
72112   bool arg4 ;
72113   float result;
72114
72115   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72116   arg2 = (unsigned int)jarg2;
72117   arg3 = (unsigned int *)jarg3;
72118   arg4 = jarg4 ? true : false;
72119   {
72120     try {
72121       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72122     } catch (std::out_of_range& e) {
72123       {
72124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72125       };
72126     } catch (std::exception& e) {
72127       {
72128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72129       };
72130     } catch (...) {
72131       {
72132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72133       };
72134     }
72135   }
72136   jresult = result;
72137   return jresult;
72138 }
72139
72140
72141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72142   unsigned int jresult ;
72143   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72144   float arg2 ;
72145   bool arg3 ;
72146   unsigned int result;
72147
72148   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72149   arg2 = (float)jarg2;
72150   arg3 = jarg3 ? true : false;
72151   {
72152     try {
72153       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72154     } catch (std::out_of_range& e) {
72155       {
72156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72157       };
72158     } catch (std::exception& e) {
72159       {
72160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72161       };
72162     } catch (...) {
72163       {
72164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72165       };
72166     }
72167   }
72168   jresult = result;
72169   return jresult;
72170 }
72171
72172
72173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72174   unsigned int jresult ;
72175   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72176   unsigned int result;
72177
72178   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72179   {
72180     try {
72181       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72182     } catch (std::out_of_range& e) {
72183       {
72184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72185       };
72186     } catch (std::exception& e) {
72187       {
72188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72189       };
72190     } catch (...) {
72191       {
72192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72193       };
72194     }
72195   }
72196   jresult = result;
72197   return jresult;
72198 }
72199
72200
72201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72202   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72203
72204   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72205   {
72206     try {
72207       delete arg1;
72208     } catch (std::out_of_range& e) {
72209       {
72210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72211       };
72212     } catch (std::exception& e) {
72213       {
72214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72215       };
72216     } catch (...) {
72217       {
72218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72219       };
72220     }
72221   }
72222 }
72223
72224
72225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72226   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72227   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72228
72229   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72230   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72231   if (arg1) (arg1)->scale = *arg2;
72232 }
72233
72234
72235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72236   void * jresult ;
72237   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72238   Dali::Toolkit::ClampState2D *result = 0 ;
72239
72240   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72241   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72242   jresult = (void *)result;
72243   return jresult;
72244 }
72245
72246
72247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72248   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72249   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72250
72251   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72252   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72253   if (arg1) (arg1)->position = *arg2;
72254 }
72255
72256
72257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72258   void * jresult ;
72259   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72260   Dali::Toolkit::ClampState2D *result = 0 ;
72261
72262   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72263   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72264   jresult = (void *)result;
72265   return jresult;
72266 }
72267
72268
72269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72270   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72271   Dali::Toolkit::ClampState arg2 ;
72272
72273   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72274   arg2 = (Dali::Toolkit::ClampState)jarg2;
72275   if (arg1) (arg1)->rotation = arg2;
72276 }
72277
72278
72279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72280   int jresult ;
72281   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72282   Dali::Toolkit::ClampState result;
72283
72284   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72285   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72286   jresult = (int)result;
72287   return jresult;
72288 }
72289
72290
72291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72292   void * jresult ;
72293   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72294
72295   {
72296     try {
72297       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72298     } catch (std::out_of_range& e) {
72299       {
72300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72301       };
72302     } catch (std::exception& e) {
72303       {
72304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72305       };
72306     } catch (...) {
72307       {
72308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72309       };
72310     }
72311   }
72312   jresult = (void *)result;
72313   return jresult;
72314 }
72315
72316
72317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72318   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72319
72320   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72321   {
72322     try {
72323       delete arg1;
72324     } catch (std::out_of_range& e) {
72325       {
72326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72327       };
72328     } catch (std::exception& e) {
72329       {
72330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72331       };
72332     } catch (...) {
72333       {
72334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72335       };
72336     }
72337   }
72338 }
72339
72340
72341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72342   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72343   Dali::Toolkit::SnapType arg2 ;
72344
72345   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72346   arg2 = (Dali::Toolkit::SnapType)jarg2;
72347   if (arg1) (arg1)->type = arg2;
72348 }
72349
72350
72351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72352   int jresult ;
72353   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72354   Dali::Toolkit::SnapType result;
72355
72356   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72357   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72358   jresult = (int)result;
72359   return jresult;
72360 }
72361
72362
72363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72364   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72365   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72366
72367   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72368   arg2 = (Dali::Vector2 *)jarg2;
72369   if (arg1) (arg1)->position = *arg2;
72370 }
72371
72372
72373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72374   void * jresult ;
72375   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72376   Dali::Vector2 *result = 0 ;
72377
72378   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72379   result = (Dali::Vector2 *)& ((arg1)->position);
72380   jresult = (void *)result;
72381   return jresult;
72382 }
72383
72384
72385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72386   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72387   float arg2 ;
72388
72389   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72390   arg2 = (float)jarg2;
72391   if (arg1) (arg1)->duration = arg2;
72392 }
72393
72394
72395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72396   float jresult ;
72397   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72398   float result;
72399
72400   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72401   result = (float) ((arg1)->duration);
72402   jresult = result;
72403   return jresult;
72404 }
72405
72406
72407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
72408   void * jresult ;
72409   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
72410
72411   {
72412     try {
72413       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
72414     } catch (std::out_of_range& e) {
72415       {
72416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72417       };
72418     } catch (std::exception& e) {
72419       {
72420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72421       };
72422     } catch (...) {
72423       {
72424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72425       };
72426     }
72427   }
72428   jresult = (void *)result;
72429   return jresult;
72430 }
72431
72432
72433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
72434   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72435
72436   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72437   {
72438     try {
72439       delete arg1;
72440     } catch (std::out_of_range& e) {
72441       {
72442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72443       };
72444     } catch (std::exception& e) {
72445       {
72446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72447       };
72448     } catch (...) {
72449       {
72450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72451       };
72452     }
72453   }
72454 }
72455
72456
72457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
72458   int jresult ;
72459   int result;
72460
72461   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
72462   jresult = (int)result;
72463   return jresult;
72464 }
72465
72466
72467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
72468   int jresult ;
72469   int result;
72470
72471   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
72472   jresult = (int)result;
72473   return jresult;
72474 }
72475
72476
72477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
72478   int jresult ;
72479   int result;
72480
72481   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
72482   jresult = (int)result;
72483   return jresult;
72484 }
72485
72486
72487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72488   int jresult ;
72489   int result;
72490
72491   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72492   jresult = (int)result;
72493   return jresult;
72494 }
72495
72496
72497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
72498   int jresult ;
72499   int result;
72500
72501   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
72502   jresult = (int)result;
72503   return jresult;
72504 }
72505
72506
72507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
72508   int jresult ;
72509   int result;
72510
72511   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
72512   jresult = (int)result;
72513   return jresult;
72514 }
72515
72516
72517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
72518   int jresult ;
72519   int result;
72520
72521   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
72522   jresult = (int)result;
72523   return jresult;
72524 }
72525
72526
72527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
72528   int jresult ;
72529   int result;
72530
72531   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
72532   jresult = (int)result;
72533   return jresult;
72534 }
72535
72536
72537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
72538   int jresult ;
72539   int result;
72540
72541   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
72542   jresult = (int)result;
72543   return jresult;
72544 }
72545
72546
72547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
72548   int jresult ;
72549   int result;
72550
72551   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
72552   jresult = (int)result;
72553   return jresult;
72554 }
72555
72556
72557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
72558   int jresult ;
72559   int result;
72560
72561   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
72562   jresult = (int)result;
72563   return jresult;
72564 }
72565
72566
72567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
72568   int jresult ;
72569   int result;
72570
72571   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
72572   jresult = (int)result;
72573   return jresult;
72574 }
72575
72576
72577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
72578   int jresult ;
72579   int result;
72580
72581   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
72582   jresult = (int)result;
72583   return jresult;
72584 }
72585
72586
72587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
72588   int jresult ;
72589   int result;
72590
72591   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
72592   jresult = (int)result;
72593   return jresult;
72594 }
72595
72596
72597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
72598   int jresult ;
72599   int result;
72600
72601   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
72602   jresult = (int)result;
72603   return jresult;
72604 }
72605
72606
72607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
72608   int jresult ;
72609   int result;
72610
72611   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
72612   jresult = (int)result;
72613   return jresult;
72614 }
72615
72616
72617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
72618   int jresult ;
72619   int result;
72620
72621   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
72622   jresult = (int)result;
72623   return jresult;
72624 }
72625
72626
72627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
72628   int jresult ;
72629   int result;
72630
72631   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
72632   jresult = (int)result;
72633   return jresult;
72634 }
72635
72636
72637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
72638   int jresult ;
72639   int result;
72640
72641   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
72642   jresult = (int)result;
72643   return jresult;
72644 }
72645
72646
72647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
72648   int jresult ;
72649   int result;
72650
72651   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
72652   jresult = (int)result;
72653   return jresult;
72654 }
72655
72656
72657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
72658   int jresult ;
72659   int result;
72660
72661   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
72662   jresult = (int)result;
72663   return jresult;
72664 }
72665
72666
72667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
72668   int jresult ;
72669   int result;
72670
72671   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
72672   jresult = (int)result;
72673   return jresult;
72674 }
72675
72676
72677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
72678   int jresult ;
72679   int result;
72680
72681   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
72682   jresult = (int)result;
72683   return jresult;
72684 }
72685
72686
72687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
72688   int jresult ;
72689   int result;
72690
72691   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
72692   jresult = (int)result;
72693   return jresult;
72694 }
72695
72696
72697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
72698   int jresult ;
72699   int result;
72700
72701   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
72702   jresult = (int)result;
72703   return jresult;
72704 }
72705
72706
72707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
72708   void * jresult ;
72709   Dali::Toolkit::ScrollView::Property *result = 0 ;
72710
72711   {
72712     try {
72713       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
72714     } catch (std::out_of_range& e) {
72715       {
72716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72717       };
72718     } catch (std::exception& e) {
72719       {
72720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72721       };
72722     } catch (...) {
72723       {
72724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72725       };
72726     }
72727   }
72728   jresult = (void *)result;
72729   return jresult;
72730 }
72731
72732
72733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
72734   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
72735
72736   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
72737   {
72738     try {
72739       delete arg1;
72740     } catch (std::out_of_range& e) {
72741       {
72742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72743       };
72744     } catch (std::exception& e) {
72745       {
72746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72747       };
72748     } catch (...) {
72749       {
72750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72751       };
72752     }
72753   }
72754 }
72755
72756
72757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
72758   void * jresult ;
72759   Dali::Toolkit::ScrollView *result = 0 ;
72760
72761   {
72762     try {
72763       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
72764     } catch (std::out_of_range& e) {
72765       {
72766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72767       };
72768     } catch (std::exception& e) {
72769       {
72770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72771       };
72772     } catch (...) {
72773       {
72774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72775       };
72776     }
72777   }
72778   jresult = (void *)result;
72779   return jresult;
72780 }
72781
72782
72783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
72784   void * jresult ;
72785   Dali::Toolkit::ScrollView *arg1 = 0 ;
72786   Dali::Toolkit::ScrollView *result = 0 ;
72787
72788   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72789   if (!arg1) {
72790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
72791     return 0;
72792   }
72793   {
72794     try {
72795       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
72796     } catch (std::out_of_range& e) {
72797       {
72798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72799       };
72800     } catch (std::exception& e) {
72801       {
72802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72803       };
72804     } catch (...) {
72805       {
72806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72807       };
72808     }
72809   }
72810   jresult = (void *)result;
72811   return jresult;
72812 }
72813
72814
72815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
72816   void * jresult ;
72817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72818   Dali::Toolkit::ScrollView *arg2 = 0 ;
72819   Dali::Toolkit::ScrollView *result = 0 ;
72820
72821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72822   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
72823   if (!arg2) {
72824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
72825     return 0;
72826   }
72827   {
72828     try {
72829       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
72830     } catch (std::out_of_range& e) {
72831       {
72832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72833       };
72834     } catch (std::exception& e) {
72835       {
72836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72837       };
72838     } catch (...) {
72839       {
72840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72841       };
72842     }
72843   }
72844   jresult = (void *)result;
72845   return jresult;
72846 }
72847
72848
72849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
72850   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72851
72852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72853   {
72854     try {
72855       delete arg1;
72856     } catch (std::out_of_range& e) {
72857       {
72858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72859       };
72860     } catch (std::exception& e) {
72861       {
72862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72863       };
72864     } catch (...) {
72865       {
72866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72867       };
72868     }
72869   }
72870 }
72871
72872
72873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
72874   void * jresult ;
72875   Dali::Toolkit::ScrollView result;
72876
72877   {
72878     try {
72879       result = Dali::Toolkit::ScrollView::New();
72880     } catch (std::out_of_range& e) {
72881       {
72882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72883       };
72884     } catch (std::exception& e) {
72885       {
72886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72887       };
72888     } catch (...) {
72889       {
72890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72891       };
72892     }
72893   }
72894   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
72895   return jresult;
72896 }
72897
72898
72899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
72900   void * jresult ;
72901   Dali::BaseHandle arg1 ;
72902   Dali::BaseHandle *argp1 ;
72903   Dali::Toolkit::ScrollView result;
72904
72905   argp1 = (Dali::BaseHandle *)jarg1;
72906   if (!argp1) {
72907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72908     return 0;
72909   }
72910   arg1 = *argp1;
72911   {
72912     try {
72913       result = Dali::Toolkit::ScrollView::DownCast(arg1);
72914     } catch (std::out_of_range& e) {
72915       {
72916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72917       };
72918     } catch (std::exception& e) {
72919       {
72920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72921       };
72922     } catch (...) {
72923       {
72924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72925       };
72926     }
72927   }
72928   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
72929   return jresult;
72930 }
72931
72932
72933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
72934   void * jresult ;
72935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72936   Dali::AlphaFunction result;
72937
72938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72939   {
72940     try {
72941       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
72942     } catch (std::out_of_range& e) {
72943       {
72944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72945       };
72946     } catch (std::exception& e) {
72947       {
72948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72949       };
72950     } catch (...) {
72951       {
72952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72953       };
72954     }
72955   }
72956   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
72957   return jresult;
72958 }
72959
72960
72961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
72962   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72963   Dali::AlphaFunction arg2 ;
72964   Dali::AlphaFunction *argp2 ;
72965
72966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72967   argp2 = (Dali::AlphaFunction *)jarg2;
72968   if (!argp2) {
72969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
72970     return ;
72971   }
72972   arg2 = *argp2;
72973   {
72974     try {
72975       (arg1)->SetScrollSnapAlphaFunction(arg2);
72976     } catch (std::out_of_range& e) {
72977       {
72978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72979       };
72980     } catch (std::exception& e) {
72981       {
72982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72983       };
72984     } catch (...) {
72985       {
72986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72987       };
72988     }
72989   }
72990 }
72991
72992
72993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
72994   void * jresult ;
72995   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72996   Dali::AlphaFunction result;
72997
72998   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72999   {
73000     try {
73001       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73002     } catch (std::out_of_range& e) {
73003       {
73004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73005       };
73006     } catch (std::exception& e) {
73007       {
73008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73009       };
73010     } catch (...) {
73011       {
73012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73013       };
73014     }
73015   }
73016   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73017   return jresult;
73018 }
73019
73020
73021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73022   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73023   Dali::AlphaFunction arg2 ;
73024   Dali::AlphaFunction *argp2 ;
73025
73026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73027   argp2 = (Dali::AlphaFunction *)jarg2;
73028   if (!argp2) {
73029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73030     return ;
73031   }
73032   arg2 = *argp2;
73033   {
73034     try {
73035       (arg1)->SetScrollFlickAlphaFunction(arg2);
73036     } catch (std::out_of_range& e) {
73037       {
73038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73039       };
73040     } catch (std::exception& e) {
73041       {
73042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73043       };
73044     } catch (...) {
73045       {
73046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73047       };
73048     }
73049   }
73050 }
73051
73052
73053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73054   float jresult ;
73055   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73056   float result;
73057
73058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73059   {
73060     try {
73061       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73062     } catch (std::out_of_range& e) {
73063       {
73064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73065       };
73066     } catch (std::exception& e) {
73067       {
73068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73069       };
73070     } catch (...) {
73071       {
73072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73073       };
73074     }
73075   }
73076   jresult = result;
73077   return jresult;
73078 }
73079
73080
73081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73082   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73083   float arg2 ;
73084
73085   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73086   arg2 = (float)jarg2;
73087   {
73088     try {
73089       (arg1)->SetScrollSnapDuration(arg2);
73090     } catch (std::out_of_range& e) {
73091       {
73092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73093       };
73094     } catch (std::exception& e) {
73095       {
73096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73097       };
73098     } catch (...) {
73099       {
73100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73101       };
73102     }
73103   }
73104 }
73105
73106
73107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73108   float jresult ;
73109   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73110   float result;
73111
73112   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73113   {
73114     try {
73115       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73116     } catch (std::out_of_range& e) {
73117       {
73118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73119       };
73120     } catch (std::exception& e) {
73121       {
73122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73123       };
73124     } catch (...) {
73125       {
73126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73127       };
73128     }
73129   }
73130   jresult = result;
73131   return jresult;
73132 }
73133
73134
73135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73136   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73137   float arg2 ;
73138
73139   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73140   arg2 = (float)jarg2;
73141   {
73142     try {
73143       (arg1)->SetScrollFlickDuration(arg2);
73144     } catch (std::out_of_range& e) {
73145       {
73146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73147       };
73148     } catch (std::exception& e) {
73149       {
73150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73151       };
73152     } catch (...) {
73153       {
73154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73155       };
73156     }
73157   }
73158 }
73159
73160
73161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73162   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73163   Dali::Toolkit::RulerPtr arg2 ;
73164   Dali::Toolkit::RulerPtr *argp2 ;
73165
73166   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73167   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73168   if (!argp2) {
73169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73170     return ;
73171   }
73172   arg2 = *argp2;
73173   {
73174     try {
73175       (arg1)->SetRulerX(arg2);
73176     } catch (std::out_of_range& e) {
73177       {
73178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73179       };
73180     } catch (std::exception& e) {
73181       {
73182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73183       };
73184     } catch (...) {
73185       {
73186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73187       };
73188     }
73189   }
73190 }
73191
73192
73193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73194   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73195   Dali::Toolkit::RulerPtr arg2 ;
73196   Dali::Toolkit::RulerPtr *argp2 ;
73197
73198   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73199   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73200   if (!argp2) {
73201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73202     return ;
73203   }
73204   arg2 = *argp2;
73205   {
73206     try {
73207       (arg1)->SetRulerY(arg2);
73208     } catch (std::out_of_range& e) {
73209       {
73210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73211       };
73212     } catch (std::exception& e) {
73213       {
73214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73215       };
73216     } catch (...) {
73217       {
73218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73219       };
73220     }
73221   }
73222 }
73223
73224
73225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73226   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73227   bool arg2 ;
73228
73229   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73230   arg2 = jarg2 ? true : false;
73231   {
73232     try {
73233       (arg1)->SetScrollSensitive(arg2);
73234     } catch (std::out_of_range& e) {
73235       {
73236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73237       };
73238     } catch (std::exception& e) {
73239       {
73240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73241       };
73242     } catch (...) {
73243       {
73244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73245       };
73246     }
73247   }
73248 }
73249
73250
73251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73252   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73253   float arg2 ;
73254   float arg3 ;
73255
73256   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73257   arg2 = (float)jarg2;
73258   arg3 = (float)jarg3;
73259   {
73260     try {
73261       (arg1)->SetMaxOvershoot(arg2,arg3);
73262     } catch (std::out_of_range& e) {
73263       {
73264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73265       };
73266     } catch (std::exception& e) {
73267       {
73268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73269       };
73270     } catch (...) {
73271       {
73272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73273       };
73274     }
73275   }
73276 }
73277
73278
73279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73280   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73281   Dali::AlphaFunction arg2 ;
73282   Dali::AlphaFunction *argp2 ;
73283
73284   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73285   argp2 = (Dali::AlphaFunction *)jarg2;
73286   if (!argp2) {
73287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73288     return ;
73289   }
73290   arg2 = *argp2;
73291   {
73292     try {
73293       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73294     } catch (std::out_of_range& e) {
73295       {
73296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73297       };
73298     } catch (std::exception& e) {
73299       {
73300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73301       };
73302     } catch (...) {
73303       {
73304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73305       };
73306     }
73307   }
73308 }
73309
73310
73311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73312   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73313   float arg2 ;
73314
73315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73316   arg2 = (float)jarg2;
73317   {
73318     try {
73319       (arg1)->SetSnapOvershootDuration(arg2);
73320     } catch (std::out_of_range& e) {
73321       {
73322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73323       };
73324     } catch (std::exception& e) {
73325       {
73326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73327       };
73328     } catch (...) {
73329       {
73330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73331       };
73332     }
73333   }
73334 }
73335
73336
73337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73338   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73339   bool arg2 ;
73340
73341   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73342   arg2 = jarg2 ? true : false;
73343   {
73344     try {
73345       (arg1)->SetActorAutoSnap(arg2);
73346     } catch (std::out_of_range& e) {
73347       {
73348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73349       };
73350     } catch (std::exception& e) {
73351       {
73352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73353       };
73354     } catch (...) {
73355       {
73356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73357       };
73358     }
73359   }
73360 }
73361
73362
73363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73364   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73365   bool arg2 ;
73366
73367   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73368   arg2 = jarg2 ? true : false;
73369   {
73370     try {
73371       (arg1)->SetWrapMode(arg2);
73372     } catch (std::out_of_range& e) {
73373       {
73374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73375       };
73376     } catch (std::exception& e) {
73377       {
73378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73379       };
73380     } catch (...) {
73381       {
73382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73383       };
73384     }
73385   }
73386 }
73387
73388
73389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73390   int jresult ;
73391   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73392   int result;
73393
73394   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73395   {
73396     try {
73397       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73398     } catch (std::out_of_range& e) {
73399       {
73400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73401       };
73402     } catch (std::exception& e) {
73403       {
73404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73405       };
73406     } catch (...) {
73407       {
73408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73409       };
73410     }
73411   }
73412   jresult = result;
73413   return jresult;
73414 }
73415
73416
73417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
73418   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73419   int arg2 ;
73420
73421   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73422   arg2 = (int)jarg2;
73423   {
73424     try {
73425       (arg1)->SetScrollUpdateDistance(arg2);
73426     } catch (std::out_of_range& e) {
73427       {
73428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73429       };
73430     } catch (std::exception& e) {
73431       {
73432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73433       };
73434     } catch (...) {
73435       {
73436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73437       };
73438     }
73439   }
73440 }
73441
73442
73443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
73444   unsigned int jresult ;
73445   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73446   bool result;
73447
73448   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73449   {
73450     try {
73451       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
73452     } catch (std::out_of_range& e) {
73453       {
73454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73455       };
73456     } catch (std::exception& e) {
73457       {
73458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73459       };
73460     } catch (...) {
73461       {
73462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73463       };
73464     }
73465   }
73466   jresult = result;
73467   return jresult;
73468 }
73469
73470
73471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
73472   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73473   bool arg2 ;
73474
73475   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73476   arg2 = jarg2 ? true : false;
73477   {
73478     try {
73479       (arg1)->SetAxisAutoLock(arg2);
73480     } catch (std::out_of_range& e) {
73481       {
73482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73483       };
73484     } catch (std::exception& e) {
73485       {
73486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73487       };
73488     } catch (...) {
73489       {
73490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73491       };
73492     }
73493   }
73494 }
73495
73496
73497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
73498   float jresult ;
73499   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73500   float result;
73501
73502   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73503   {
73504     try {
73505       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
73506     } catch (std::out_of_range& e) {
73507       {
73508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73509       };
73510     } catch (std::exception& e) {
73511       {
73512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73513       };
73514     } catch (...) {
73515       {
73516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73517       };
73518     }
73519   }
73520   jresult = result;
73521   return jresult;
73522 }
73523
73524
73525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
73526   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73527   float arg2 ;
73528
73529   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73530   arg2 = (float)jarg2;
73531   {
73532     try {
73533       (arg1)->SetAxisAutoLockGradient(arg2);
73534     } catch (std::out_of_range& e) {
73535       {
73536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73537       };
73538     } catch (std::exception& e) {
73539       {
73540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73541       };
73542     } catch (...) {
73543       {
73544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73545       };
73546     }
73547   }
73548 }
73549
73550
73551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
73552   float jresult ;
73553   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73554   float result;
73555
73556   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73557   {
73558     try {
73559       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
73560     } catch (std::out_of_range& e) {
73561       {
73562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73563       };
73564     } catch (std::exception& e) {
73565       {
73566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73567       };
73568     } catch (...) {
73569       {
73570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73571       };
73572     }
73573   }
73574   jresult = result;
73575   return jresult;
73576 }
73577
73578
73579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
73580   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73581   float arg2 ;
73582
73583   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73584   arg2 = (float)jarg2;
73585   {
73586     try {
73587       (arg1)->SetFrictionCoefficient(arg2);
73588     } catch (std::out_of_range& e) {
73589       {
73590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73591       };
73592     } catch (std::exception& e) {
73593       {
73594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73595       };
73596     } catch (...) {
73597       {
73598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73599       };
73600     }
73601   }
73602 }
73603
73604
73605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
73606   float jresult ;
73607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73608   float result;
73609
73610   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73611   {
73612     try {
73613       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
73614     } catch (std::out_of_range& e) {
73615       {
73616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73617       };
73618     } catch (std::exception& e) {
73619       {
73620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73621       };
73622     } catch (...) {
73623       {
73624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73625       };
73626     }
73627   }
73628   jresult = result;
73629   return jresult;
73630 }
73631
73632
73633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
73634   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73635   float arg2 ;
73636
73637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73638   arg2 = (float)jarg2;
73639   {
73640     try {
73641       (arg1)->SetFlickSpeedCoefficient(arg2);
73642     } catch (std::out_of_range& e) {
73643       {
73644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73645       };
73646     } catch (std::exception& e) {
73647       {
73648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73649       };
73650     } catch (...) {
73651       {
73652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73653       };
73654     }
73655   }
73656 }
73657
73658
73659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
73660   void * jresult ;
73661   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73662   Dali::Vector2 result;
73663
73664   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73665   {
73666     try {
73667       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
73668     } catch (std::out_of_range& e) {
73669       {
73670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73671       };
73672     } catch (std::exception& e) {
73673       {
73674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73675       };
73676     } catch (...) {
73677       {
73678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73679       };
73680     }
73681   }
73682   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73683   return jresult;
73684 }
73685
73686
73687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
73688   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73689   Dali::Vector2 *arg2 = 0 ;
73690
73691   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73692   arg2 = (Dali::Vector2 *)jarg2;
73693   if (!arg2) {
73694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
73695     return ;
73696   }
73697   {
73698     try {
73699       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
73700     } catch (std::out_of_range& e) {
73701       {
73702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73703       };
73704     } catch (std::exception& e) {
73705       {
73706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73707       };
73708     } catch (...) {
73709       {
73710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73711       };
73712     }
73713   }
73714 }
73715
73716
73717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
73718   float jresult ;
73719   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73720   float result;
73721
73722   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73723   {
73724     try {
73725       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
73726     } catch (std::out_of_range& e) {
73727       {
73728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73729       };
73730     } catch (std::exception& e) {
73731       {
73732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73733       };
73734     } catch (...) {
73735       {
73736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73737       };
73738     }
73739   }
73740   jresult = result;
73741   return jresult;
73742 }
73743
73744
73745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
73746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73747   float arg2 ;
73748
73749   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73750   arg2 = (float)jarg2;
73751   {
73752     try {
73753       (arg1)->SetMinimumSpeedForFlick(arg2);
73754     } catch (std::out_of_range& e) {
73755       {
73756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73757       };
73758     } catch (std::exception& e) {
73759       {
73760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73761       };
73762     } catch (...) {
73763       {
73764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73765       };
73766     }
73767   }
73768 }
73769
73770
73771 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
73772   float jresult ;
73773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73774   float result;
73775
73776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73777   {
73778     try {
73779       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
73780     } catch (std::out_of_range& e) {
73781       {
73782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73783       };
73784     } catch (std::exception& e) {
73785       {
73786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73787       };
73788     } catch (...) {
73789       {
73790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73791       };
73792     }
73793   }
73794   jresult = result;
73795   return jresult;
73796 }
73797
73798
73799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
73800   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73801   float arg2 ;
73802
73803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73804   arg2 = (float)jarg2;
73805   {
73806     try {
73807       (arg1)->SetMaxFlickSpeed(arg2);
73808     } catch (std::out_of_range& e) {
73809       {
73810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73811       };
73812     } catch (std::exception& e) {
73813       {
73814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73815       };
73816     } catch (...) {
73817       {
73818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73819       };
73820     }
73821   }
73822 }
73823
73824
73825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
73826   void * jresult ;
73827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73828   Dali::Vector2 result;
73829
73830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73831   {
73832     try {
73833       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
73834     } catch (std::out_of_range& e) {
73835       {
73836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73837       };
73838     } catch (std::exception& e) {
73839       {
73840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73841       };
73842     } catch (...) {
73843       {
73844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73845       };
73846     }
73847   }
73848   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73849   return jresult;
73850 }
73851
73852
73853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
73854   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73855   Dali::Vector2 arg2 ;
73856   Dali::Vector2 *argp2 ;
73857
73858   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73859   argp2 = (Dali::Vector2 *)jarg2;
73860   if (!argp2) {
73861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
73862     return ;
73863   }
73864   arg2 = *argp2;
73865   {
73866     try {
73867       (arg1)->SetWheelScrollDistanceStep(arg2);
73868     } catch (std::out_of_range& e) {
73869       {
73870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73871       };
73872     } catch (std::exception& e) {
73873       {
73874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73875       };
73876     } catch (...) {
73877       {
73878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73879       };
73880     }
73881   }
73882 }
73883
73884
73885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
73886   void * jresult ;
73887   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73888   Dali::Vector2 result;
73889
73890   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73891   {
73892     try {
73893       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
73894     } catch (std::out_of_range& e) {
73895       {
73896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73897       };
73898     } catch (std::exception& e) {
73899       {
73900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73901       };
73902     } catch (...) {
73903       {
73904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73905       };
73906     }
73907   }
73908   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73909   return jresult;
73910 }
73911
73912
73913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
73914   unsigned int jresult ;
73915   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73916   unsigned int result;
73917
73918   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73919   {
73920     try {
73921       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
73922     } catch (std::out_of_range& e) {
73923       {
73924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73925       };
73926     } catch (std::exception& e) {
73927       {
73928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73929       };
73930     } catch (...) {
73931       {
73932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73933       };
73934     }
73935   }
73936   jresult = result;
73937   return jresult;
73938 }
73939
73940
73941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
73942   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73943   Dali::Vector2 *arg2 = 0 ;
73944
73945   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73946   arg2 = (Dali::Vector2 *)jarg2;
73947   if (!arg2) {
73948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
73949     return ;
73950   }
73951   {
73952     try {
73953       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
73954     } catch (std::out_of_range& e) {
73955       {
73956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73957       };
73958     } catch (std::exception& e) {
73959       {
73960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73961       };
73962     } catch (...) {
73963       {
73964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73965       };
73966     }
73967   }
73968 }
73969
73970
73971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
73972   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73973   Dali::Vector2 *arg2 = 0 ;
73974   float arg3 ;
73975
73976   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73977   arg2 = (Dali::Vector2 *)jarg2;
73978   if (!arg2) {
73979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
73980     return ;
73981   }
73982   arg3 = (float)jarg3;
73983   {
73984     try {
73985       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
73986     } catch (std::out_of_range& e) {
73987       {
73988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73989       };
73990     } catch (std::exception& e) {
73991       {
73992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73993       };
73994     } catch (...) {
73995       {
73996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73997       };
73998     }
73999   }
74000 }
74001
74002
74003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74004   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74005   Dali::Vector2 *arg2 = 0 ;
74006   float arg3 ;
74007   Dali::AlphaFunction arg4 ;
74008   Dali::AlphaFunction *argp4 ;
74009
74010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74011   arg2 = (Dali::Vector2 *)jarg2;
74012   if (!arg2) {
74013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74014     return ;
74015   }
74016   arg3 = (float)jarg3;
74017   argp4 = (Dali::AlphaFunction *)jarg4;
74018   if (!argp4) {
74019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74020     return ;
74021   }
74022   arg4 = *argp4;
74023   {
74024     try {
74025       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74026     } catch (std::out_of_range& e) {
74027       {
74028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74029       };
74030     } catch (std::exception& e) {
74031       {
74032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74033       };
74034     } catch (...) {
74035       {
74036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74037       };
74038     }
74039   }
74040 }
74041
74042
74043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74044   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74045   Dali::Vector2 *arg2 = 0 ;
74046   float arg3 ;
74047   Dali::Toolkit::DirectionBias arg4 ;
74048   Dali::Toolkit::DirectionBias arg5 ;
74049
74050   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74051   arg2 = (Dali::Vector2 *)jarg2;
74052   if (!arg2) {
74053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74054     return ;
74055   }
74056   arg3 = (float)jarg3;
74057   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74058   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74059   {
74060     try {
74061       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74062     } catch (std::out_of_range& e) {
74063       {
74064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74065       };
74066     } catch (std::exception& e) {
74067       {
74068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74069       };
74070     } catch (...) {
74071       {
74072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74073       };
74074     }
74075   }
74076 }
74077
74078
74079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74080   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74081   Dali::Vector2 *arg2 = 0 ;
74082   float arg3 ;
74083   Dali::AlphaFunction arg4 ;
74084   Dali::Toolkit::DirectionBias arg5 ;
74085   Dali::Toolkit::DirectionBias arg6 ;
74086   Dali::AlphaFunction *argp4 ;
74087
74088   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74089   arg2 = (Dali::Vector2 *)jarg2;
74090   if (!arg2) {
74091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74092     return ;
74093   }
74094   arg3 = (float)jarg3;
74095   argp4 = (Dali::AlphaFunction *)jarg4;
74096   if (!argp4) {
74097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74098     return ;
74099   }
74100   arg4 = *argp4;
74101   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74102   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74103   {
74104     try {
74105       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74106     } catch (std::out_of_range& e) {
74107       {
74108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74109       };
74110     } catch (std::exception& e) {
74111       {
74112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74113       };
74114     } catch (...) {
74115       {
74116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74117       };
74118     }
74119   }
74120 }
74121
74122
74123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74124   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74125   unsigned int arg2 ;
74126
74127   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74128   arg2 = (unsigned int)jarg2;
74129   {
74130     try {
74131       (arg1)->ScrollTo(arg2);
74132     } catch (std::out_of_range& e) {
74133       {
74134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74135       };
74136     } catch (std::exception& e) {
74137       {
74138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74139       };
74140     } catch (...) {
74141       {
74142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74143       };
74144     }
74145   }
74146 }
74147
74148
74149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74150   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74151   unsigned int arg2 ;
74152   float arg3 ;
74153
74154   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74155   arg2 = (unsigned int)jarg2;
74156   arg3 = (float)jarg3;
74157   {
74158     try {
74159       (arg1)->ScrollTo(arg2,arg3);
74160     } catch (std::out_of_range& e) {
74161       {
74162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74163       };
74164     } catch (std::exception& e) {
74165       {
74166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74167       };
74168     } catch (...) {
74169       {
74170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74171       };
74172     }
74173   }
74174 }
74175
74176
74177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74179   unsigned int arg2 ;
74180   float arg3 ;
74181   Dali::Toolkit::DirectionBias arg4 ;
74182
74183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74184   arg2 = (unsigned int)jarg2;
74185   arg3 = (float)jarg3;
74186   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74187   {
74188     try {
74189       (arg1)->ScrollTo(arg2,arg3,arg4);
74190     } catch (std::out_of_range& e) {
74191       {
74192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74193       };
74194     } catch (std::exception& e) {
74195       {
74196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74197       };
74198     } catch (...) {
74199       {
74200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74201       };
74202     }
74203   }
74204 }
74205
74206
74207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74208   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74209   Dali::Actor *arg2 = 0 ;
74210
74211   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74212   arg2 = (Dali::Actor *)jarg2;
74213   if (!arg2) {
74214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74215     return ;
74216   }
74217   {
74218     try {
74219       (arg1)->ScrollTo(*arg2);
74220     } catch (std::out_of_range& e) {
74221       {
74222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74223       };
74224     } catch (std::exception& e) {
74225       {
74226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74227       };
74228     } catch (...) {
74229       {
74230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74231       };
74232     }
74233   }
74234 }
74235
74236
74237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74238   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74239   Dali::Actor *arg2 = 0 ;
74240   float arg3 ;
74241
74242   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74243   arg2 = (Dali::Actor *)jarg2;
74244   if (!arg2) {
74245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74246     return ;
74247   }
74248   arg3 = (float)jarg3;
74249   {
74250     try {
74251       (arg1)->ScrollTo(*arg2,arg3);
74252     } catch (std::out_of_range& e) {
74253       {
74254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74255       };
74256     } catch (std::exception& e) {
74257       {
74258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74259       };
74260     } catch (...) {
74261       {
74262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74263       };
74264     }
74265   }
74266 }
74267
74268
74269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74270   unsigned int jresult ;
74271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74272   bool result;
74273
74274   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74275   {
74276     try {
74277       result = (bool)(arg1)->ScrollToSnapPoint();
74278     } catch (std::out_of_range& e) {
74279       {
74280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74281       };
74282     } catch (std::exception& e) {
74283       {
74284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74285       };
74286     } catch (...) {
74287       {
74288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74289       };
74290     }
74291   }
74292   jresult = result;
74293   return jresult;
74294 }
74295
74296
74297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74298   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74299   Dali::Constraint arg2 ;
74300   Dali::Constraint *argp2 ;
74301
74302   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74303   argp2 = (Dali::Constraint *)jarg2;
74304   if (!argp2) {
74305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74306     return ;
74307   }
74308   arg2 = *argp2;
74309   {
74310     try {
74311       (arg1)->ApplyConstraintToChildren(arg2);
74312     } catch (std::out_of_range& e) {
74313       {
74314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74315       };
74316     } catch (std::exception& e) {
74317       {
74318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74319       };
74320     } catch (...) {
74321       {
74322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74323       };
74324     }
74325   }
74326 }
74327
74328
74329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74330   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74331
74332   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74333   {
74334     try {
74335       (arg1)->RemoveConstraintsFromChildren();
74336     } catch (std::out_of_range& e) {
74337       {
74338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74339       };
74340     } catch (std::exception& e) {
74341       {
74342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74343       };
74344     } catch (...) {
74345       {
74346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74347       };
74348     }
74349   }
74350 }
74351
74352
74353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74354   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74355   Dali::Toolkit::ScrollViewEffect arg2 ;
74356   Dali::Toolkit::ScrollViewEffect *argp2 ;
74357
74358   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74359   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74360   if (!argp2) {
74361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74362     return ;
74363   }
74364   arg2 = *argp2;
74365   {
74366     try {
74367       (arg1)->ApplyEffect(arg2);
74368     } catch (std::out_of_range& e) {
74369       {
74370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74371       };
74372     } catch (std::exception& e) {
74373       {
74374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74375       };
74376     } catch (...) {
74377       {
74378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74379       };
74380     }
74381   }
74382 }
74383
74384
74385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74386   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74387   Dali::Toolkit::ScrollViewEffect arg2 ;
74388   Dali::Toolkit::ScrollViewEffect *argp2 ;
74389
74390   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74391   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74392   if (!argp2) {
74393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74394     return ;
74395   }
74396   arg2 = *argp2;
74397   {
74398     try {
74399       (arg1)->RemoveEffect(arg2);
74400     } catch (std::out_of_range& e) {
74401       {
74402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74403       };
74404     } catch (std::exception& e) {
74405       {
74406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74407       };
74408     } catch (...) {
74409       {
74410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74411       };
74412     }
74413   }
74414 }
74415
74416
74417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
74418   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74419
74420   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74421   {
74422     try {
74423       (arg1)->RemoveAllEffects();
74424     } catch (std::out_of_range& e) {
74425       {
74426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74427       };
74428     } catch (std::exception& e) {
74429       {
74430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74431       };
74432     } catch (...) {
74433       {
74434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74435       };
74436     }
74437   }
74438 }
74439
74440
74441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
74442   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74443   Dali::Actor arg2 ;
74444   Dali::Actor *argp2 ;
74445
74446   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74447   argp2 = (Dali::Actor *)jarg2;
74448   if (!argp2) {
74449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74450     return ;
74451   }
74452   arg2 = *argp2;
74453   {
74454     try {
74455       (arg1)->BindActor(arg2);
74456     } catch (std::out_of_range& e) {
74457       {
74458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74459       };
74460     } catch (std::exception& e) {
74461       {
74462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74463       };
74464     } catch (...) {
74465       {
74466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74467       };
74468     }
74469   }
74470 }
74471
74472
74473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
74474   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74475   Dali::Actor arg2 ;
74476   Dali::Actor *argp2 ;
74477
74478   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74479   argp2 = (Dali::Actor *)jarg2;
74480   if (!argp2) {
74481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74482     return ;
74483   }
74484   arg2 = *argp2;
74485   {
74486     try {
74487       (arg1)->UnbindActor(arg2);
74488     } catch (std::out_of_range& e) {
74489       {
74490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74491       };
74492     } catch (std::exception& e) {
74493       {
74494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74495       };
74496     } catch (...) {
74497       {
74498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74499       };
74500     }
74501   }
74502 }
74503
74504
74505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
74506   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74507   Dali::Radian arg2 ;
74508   Dali::Radian arg3 ;
74509   Dali::Radian *argp2 ;
74510   Dali::Radian *argp3 ;
74511
74512   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74513   argp2 = (Dali::Radian *)jarg2;
74514   if (!argp2) {
74515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74516     return ;
74517   }
74518   arg2 = *argp2;
74519   argp3 = (Dali::Radian *)jarg3;
74520   if (!argp3) {
74521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74522     return ;
74523   }
74524   arg3 = *argp3;
74525   {
74526     try {
74527       (arg1)->SetScrollingDirection(arg2,arg3);
74528     } catch (std::out_of_range& e) {
74529       {
74530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74531       };
74532     } catch (std::exception& e) {
74533       {
74534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74535       };
74536     } catch (...) {
74537       {
74538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74539       };
74540     }
74541   }
74542 }
74543
74544
74545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
74546   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74547   Dali::Radian arg2 ;
74548   Dali::Radian *argp2 ;
74549
74550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74551   argp2 = (Dali::Radian *)jarg2;
74552   if (!argp2) {
74553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74554     return ;
74555   }
74556   arg2 = *argp2;
74557   {
74558     try {
74559       (arg1)->SetScrollingDirection(arg2);
74560     } catch (std::out_of_range& e) {
74561       {
74562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74563       };
74564     } catch (std::exception& e) {
74565       {
74566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74567       };
74568     } catch (...) {
74569       {
74570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74571       };
74572     }
74573   }
74574 }
74575
74576
74577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
74578   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74579   Dali::Radian arg2 ;
74580   Dali::Radian *argp2 ;
74581
74582   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74583   argp2 = (Dali::Radian *)jarg2;
74584   if (!argp2) {
74585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74586     return ;
74587   }
74588   arg2 = *argp2;
74589   {
74590     try {
74591       (arg1)->RemoveScrollingDirection(arg2);
74592     } catch (std::out_of_range& e) {
74593       {
74594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74595       };
74596     } catch (std::exception& e) {
74597       {
74598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74599       };
74600     } catch (...) {
74601       {
74602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74603       };
74604     }
74605   }
74606 }
74607
74608
74609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
74610   void * jresult ;
74611   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74612   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
74613
74614   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74615   {
74616     try {
74617       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
74618     } catch (std::out_of_range& e) {
74619       {
74620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74621       };
74622     } catch (std::exception& e) {
74623       {
74624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74625       };
74626     } catch (...) {
74627       {
74628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74629       };
74630     }
74631   }
74632   jresult = (void *)result;
74633   return jresult;
74634 }
74635
74636
74637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
74638   int jresult ;
74639   int result;
74640
74641   result = (int)Dali::Toolkit::TableView::Property::ROWS;
74642   jresult = (int)result;
74643   return jresult;
74644 }
74645
74646
74647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
74648   int jresult ;
74649   int result;
74650
74651   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
74652   jresult = (int)result;
74653   return jresult;
74654 }
74655
74656
74657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
74658   int jresult ;
74659   int result;
74660
74661   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
74662   jresult = (int)result;
74663   return jresult;
74664 }
74665
74666
74667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
74668   int jresult ;
74669   int result;
74670
74671   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
74672   jresult = (int)result;
74673   return jresult;
74674 }
74675
74676
74677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
74678   int jresult ;
74679   int result;
74680
74681   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
74682   jresult = (int)result;
74683   return jresult;
74684 }
74685
74686
74687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
74688   void * jresult ;
74689   Dali::Toolkit::TableView::Property *result = 0 ;
74690
74691   {
74692     try {
74693       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
74694     } catch (std::out_of_range& e) {
74695       {
74696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74697       };
74698     } catch (std::exception& e) {
74699       {
74700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74701       };
74702     } catch (...) {
74703       {
74704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74705       };
74706     }
74707   }
74708   jresult = (void *)result;
74709   return jresult;
74710 }
74711
74712
74713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
74714   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
74715
74716   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
74717   {
74718     try {
74719       delete arg1;
74720     } catch (std::out_of_range& e) {
74721       {
74722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74723       };
74724     } catch (std::exception& e) {
74725       {
74726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74727       };
74728     } catch (...) {
74729       {
74730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74731       };
74732     }
74733   }
74734 }
74735
74736
74737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
74738   int jresult ;
74739   int result;
74740
74741   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
74742   jresult = (int)result;
74743   return jresult;
74744 }
74745
74746
74747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
74748   int jresult ;
74749   int result;
74750
74751   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
74752   jresult = (int)result;
74753   return jresult;
74754 }
74755
74756
74757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
74758   int jresult ;
74759   int result;
74760
74761   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
74762   jresult = (int)result;
74763   return jresult;
74764 }
74765
74766
74767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
74768   int jresult ;
74769   int result;
74770
74771   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
74772   jresult = (int)result;
74773   return jresult;
74774 }
74775
74776
74777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
74778   int jresult ;
74779   int result;
74780
74781   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
74782   jresult = (int)result;
74783   return jresult;
74784 }
74785
74786
74787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
74788   void * jresult ;
74789   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
74790
74791   {
74792     try {
74793       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
74794     } catch (std::out_of_range& e) {
74795       {
74796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74797       };
74798     } catch (std::exception& e) {
74799       {
74800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74801       };
74802     } catch (...) {
74803       {
74804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74805       };
74806     }
74807   }
74808   jresult = (void *)result;
74809   return jresult;
74810 }
74811
74812
74813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
74814   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
74815
74816   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
74817   {
74818     try {
74819       delete arg1;
74820     } catch (std::out_of_range& e) {
74821       {
74822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74823       };
74824     } catch (std::exception& e) {
74825       {
74826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74827       };
74828     } catch (...) {
74829       {
74830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74831       };
74832     }
74833   }
74834 }
74835
74836
74837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
74838   void * jresult ;
74839   unsigned int arg1 ;
74840   unsigned int arg2 ;
74841   unsigned int arg3 ;
74842   unsigned int arg4 ;
74843   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74844
74845   arg1 = (unsigned int)jarg1;
74846   arg2 = (unsigned int)jarg2;
74847   arg3 = (unsigned int)jarg3;
74848   arg4 = (unsigned int)jarg4;
74849   {
74850     try {
74851       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
74852     } catch (std::out_of_range& e) {
74853       {
74854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74855       };
74856     } catch (std::exception& e) {
74857       {
74858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74859       };
74860     } catch (...) {
74861       {
74862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74863       };
74864     }
74865   }
74866   jresult = (void *)result;
74867   return jresult;
74868 }
74869
74870
74871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
74872   void * jresult ;
74873   unsigned int arg1 ;
74874   unsigned int arg2 ;
74875   unsigned int arg3 ;
74876   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74877
74878   arg1 = (unsigned int)jarg1;
74879   arg2 = (unsigned int)jarg2;
74880   arg3 = (unsigned int)jarg3;
74881   {
74882     try {
74883       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
74884     } catch (std::out_of_range& e) {
74885       {
74886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74887       };
74888     } catch (std::exception& e) {
74889       {
74890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74891       };
74892     } catch (...) {
74893       {
74894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74895       };
74896     }
74897   }
74898   jresult = (void *)result;
74899   return jresult;
74900 }
74901
74902
74903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
74904   void * jresult ;
74905   unsigned int arg1 ;
74906   unsigned int arg2 ;
74907   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74908
74909   arg1 = (unsigned int)jarg1;
74910   arg2 = (unsigned int)jarg2;
74911   {
74912     try {
74913       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
74914     } catch (std::out_of_range& e) {
74915       {
74916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74917       };
74918     } catch (std::exception& e) {
74919       {
74920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74921       };
74922     } catch (...) {
74923       {
74924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74925       };
74926     }
74927   }
74928   jresult = (void *)result;
74929   return jresult;
74930 }
74931
74932
74933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
74934   void * jresult ;
74935   unsigned int arg1 ;
74936   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74937
74938   arg1 = (unsigned int)jarg1;
74939   {
74940     try {
74941       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
74942     } catch (std::out_of_range& e) {
74943       {
74944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74945       };
74946     } catch (std::exception& e) {
74947       {
74948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74949       };
74950     } catch (...) {
74951       {
74952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74953       };
74954     }
74955   }
74956   jresult = (void *)result;
74957   return jresult;
74958 }
74959
74960
74961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
74962   void * jresult ;
74963   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74964
74965   {
74966     try {
74967       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
74968     } catch (std::out_of_range& e) {
74969       {
74970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74971       };
74972     } catch (std::exception& e) {
74973       {
74974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74975       };
74976     } catch (...) {
74977       {
74978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74979       };
74980     }
74981   }
74982   jresult = (void *)result;
74983   return jresult;
74984 }
74985
74986
74987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
74988   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
74989   unsigned int arg2 ;
74990
74991   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
74992   arg2 = (unsigned int)jarg2;
74993   if (arg1) (arg1)->rowIndex = arg2;
74994 }
74995
74996
74997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
74998   unsigned int jresult ;
74999   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75000   unsigned int result;
75001
75002   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75003   result = (unsigned int) ((arg1)->rowIndex);
75004   jresult = result;
75005   return jresult;
75006 }
75007
75008
75009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75010   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75011   unsigned int arg2 ;
75012
75013   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75014   arg2 = (unsigned int)jarg2;
75015   if (arg1) (arg1)->columnIndex = arg2;
75016 }
75017
75018
75019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75020   unsigned int jresult ;
75021   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75022   unsigned int result;
75023
75024   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75025   result = (unsigned int) ((arg1)->columnIndex);
75026   jresult = result;
75027   return jresult;
75028 }
75029
75030
75031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75032   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75033   unsigned int arg2 ;
75034
75035   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75036   arg2 = (unsigned int)jarg2;
75037   if (arg1) (arg1)->rowSpan = arg2;
75038 }
75039
75040
75041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75042   unsigned int jresult ;
75043   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75044   unsigned int result;
75045
75046   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75047   result = (unsigned int) ((arg1)->rowSpan);
75048   jresult = result;
75049   return jresult;
75050 }
75051
75052
75053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75054   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75055   unsigned int arg2 ;
75056
75057   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75058   arg2 = (unsigned int)jarg2;
75059   if (arg1) (arg1)->columnSpan = arg2;
75060 }
75061
75062
75063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75064   unsigned int jresult ;
75065   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75066   unsigned int result;
75067
75068   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75069   result = (unsigned int) ((arg1)->columnSpan);
75070   jresult = result;
75071   return jresult;
75072 }
75073
75074
75075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75076   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75077
75078   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75079   {
75080     try {
75081       delete arg1;
75082     } catch (std::out_of_range& e) {
75083       {
75084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75085       };
75086     } catch (std::exception& e) {
75087       {
75088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75089       };
75090     } catch (...) {
75091       {
75092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75093       };
75094     }
75095   }
75096 }
75097
75098
75099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75100   void * jresult ;
75101   Dali::Toolkit::TableView *result = 0 ;
75102
75103   {
75104     try {
75105       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75106     } catch (std::out_of_range& e) {
75107       {
75108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75109       };
75110     } catch (std::exception& e) {
75111       {
75112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75113       };
75114     } catch (...) {
75115       {
75116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75117       };
75118     }
75119   }
75120   jresult = (void *)result;
75121   return jresult;
75122 }
75123
75124
75125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75126   void * jresult ;
75127   Dali::Toolkit::TableView *arg1 = 0 ;
75128   Dali::Toolkit::TableView *result = 0 ;
75129
75130   arg1 = (Dali::Toolkit::TableView *)jarg1;
75131   if (!arg1) {
75132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75133     return 0;
75134   }
75135   {
75136     try {
75137       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75138     } catch (std::out_of_range& e) {
75139       {
75140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75141       };
75142     } catch (std::exception& e) {
75143       {
75144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75145       };
75146     } catch (...) {
75147       {
75148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75149       };
75150     }
75151   }
75152   jresult = (void *)result;
75153   return jresult;
75154 }
75155
75156
75157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75158   void * jresult ;
75159   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75160   Dali::Toolkit::TableView *arg2 = 0 ;
75161   Dali::Toolkit::TableView *result = 0 ;
75162
75163   arg1 = (Dali::Toolkit::TableView *)jarg1;
75164   arg2 = (Dali::Toolkit::TableView *)jarg2;
75165   if (!arg2) {
75166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75167     return 0;
75168   }
75169   {
75170     try {
75171       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75172     } catch (std::out_of_range& e) {
75173       {
75174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75175       };
75176     } catch (std::exception& e) {
75177       {
75178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75179       };
75180     } catch (...) {
75181       {
75182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75183       };
75184     }
75185   }
75186   jresult = (void *)result;
75187   return jresult;
75188 }
75189
75190
75191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75192   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75193
75194   arg1 = (Dali::Toolkit::TableView *)jarg1;
75195   {
75196     try {
75197       delete arg1;
75198     } catch (std::out_of_range& e) {
75199       {
75200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75201       };
75202     } catch (std::exception& e) {
75203       {
75204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75205       };
75206     } catch (...) {
75207       {
75208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75209       };
75210     }
75211   }
75212 }
75213
75214
75215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75216   void * jresult ;
75217   unsigned int arg1 ;
75218   unsigned int arg2 ;
75219   Dali::Toolkit::TableView result;
75220
75221   arg1 = (unsigned int)jarg1;
75222   arg2 = (unsigned int)jarg2;
75223   {
75224     try {
75225       result = Dali::Toolkit::TableView::New(arg1,arg2);
75226     } catch (std::out_of_range& e) {
75227       {
75228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75229       };
75230     } catch (std::exception& e) {
75231       {
75232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75233       };
75234     } catch (...) {
75235       {
75236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75237       };
75238     }
75239   }
75240   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75241   return jresult;
75242 }
75243
75244
75245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75246   void * jresult ;
75247   Dali::BaseHandle arg1 ;
75248   Dali::BaseHandle *argp1 ;
75249   Dali::Toolkit::TableView result;
75250
75251   argp1 = (Dali::BaseHandle *)jarg1;
75252   if (!argp1) {
75253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75254     return 0;
75255   }
75256   arg1 = *argp1;
75257   {
75258     try {
75259       result = Dali::Toolkit::TableView::DownCast(arg1);
75260     } catch (std::out_of_range& e) {
75261       {
75262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75263       };
75264     } catch (std::exception& e) {
75265       {
75266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75267       };
75268     } catch (...) {
75269       {
75270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75271       };
75272     }
75273   }
75274   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75275   return jresult;
75276 }
75277
75278
75279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75280   unsigned int jresult ;
75281   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75282   Dali::Actor arg2 ;
75283   Dali::Toolkit::TableView::CellPosition arg3 ;
75284   Dali::Actor *argp2 ;
75285   Dali::Toolkit::TableView::CellPosition *argp3 ;
75286   bool result;
75287
75288   arg1 = (Dali::Toolkit::TableView *)jarg1;
75289   argp2 = (Dali::Actor *)jarg2;
75290   if (!argp2) {
75291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75292     return 0;
75293   }
75294   arg2 = *argp2;
75295   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75296   if (!argp3) {
75297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75298     return 0;
75299   }
75300   arg3 = *argp3;
75301   {
75302     try {
75303       result = (bool)(arg1)->AddChild(arg2,arg3);
75304     } catch (std::out_of_range& e) {
75305       {
75306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75307       };
75308     } catch (std::exception& e) {
75309       {
75310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75311       };
75312     } catch (...) {
75313       {
75314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75315       };
75316     }
75317   }
75318   jresult = result;
75319   return jresult;
75320 }
75321
75322
75323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75324   void * jresult ;
75325   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75326   Dali::Toolkit::TableView::CellPosition arg2 ;
75327   Dali::Toolkit::TableView::CellPosition *argp2 ;
75328   Dali::Actor result;
75329
75330   arg1 = (Dali::Toolkit::TableView *)jarg1;
75331   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75332   if (!argp2) {
75333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75334     return 0;
75335   }
75336   arg2 = *argp2;
75337   {
75338     try {
75339       result = (arg1)->GetChildAt(arg2);
75340     } catch (std::out_of_range& e) {
75341       {
75342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75343       };
75344     } catch (std::exception& e) {
75345       {
75346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75347       };
75348     } catch (...) {
75349       {
75350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75351       };
75352     }
75353   }
75354   jresult = new Dali::Actor((const Dali::Actor &)result);
75355   return jresult;
75356 }
75357
75358
75359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75360   void * jresult ;
75361   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75362   Dali::Toolkit::TableView::CellPosition arg2 ;
75363   Dali::Toolkit::TableView::CellPosition *argp2 ;
75364   Dali::Actor result;
75365
75366   arg1 = (Dali::Toolkit::TableView *)jarg1;
75367   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75368   if (!argp2) {
75369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75370     return 0;
75371   }
75372   arg2 = *argp2;
75373   {
75374     try {
75375       result = (arg1)->RemoveChildAt(arg2);
75376     } catch (std::out_of_range& e) {
75377       {
75378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75379       };
75380     } catch (std::exception& e) {
75381       {
75382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75383       };
75384     } catch (...) {
75385       {
75386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75387       };
75388     }
75389   }
75390   jresult = new Dali::Actor((const Dali::Actor &)result);
75391   return jresult;
75392 }
75393
75394
75395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75396   unsigned int jresult ;
75397   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75398   Dali::Actor arg2 ;
75399   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75400   Dali::Actor *argp2 ;
75401   bool result;
75402
75403   arg1 = (Dali::Toolkit::TableView *)jarg1;
75404   argp2 = (Dali::Actor *)jarg2;
75405   if (!argp2) {
75406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75407     return 0;
75408   }
75409   arg2 = *argp2;
75410   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75411   if (!arg3) {
75412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
75413     return 0;
75414   }
75415   {
75416     try {
75417       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
75418     } catch (std::out_of_range& e) {
75419       {
75420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75421       };
75422     } catch (std::exception& e) {
75423       {
75424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75425       };
75426     } catch (...) {
75427       {
75428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75429       };
75430     }
75431   }
75432   jresult = result;
75433   return jresult;
75434 }
75435
75436
75437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
75438   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75439   unsigned int arg2 ;
75440
75441   arg1 = (Dali::Toolkit::TableView *)jarg1;
75442   arg2 = (unsigned int)jarg2;
75443   {
75444     try {
75445       (arg1)->InsertRow(arg2);
75446     } catch (std::out_of_range& e) {
75447       {
75448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75449       };
75450     } catch (std::exception& e) {
75451       {
75452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75453       };
75454     } catch (...) {
75455       {
75456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75457       };
75458     }
75459   }
75460 }
75461
75462
75463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
75464   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75465   unsigned int arg2 ;
75466
75467   arg1 = (Dali::Toolkit::TableView *)jarg1;
75468   arg2 = (unsigned int)jarg2;
75469   {
75470     try {
75471       (arg1)->DeleteRow(arg2);
75472     } catch (std::out_of_range& e) {
75473       {
75474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75475       };
75476     } catch (std::exception& e) {
75477       {
75478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75479       };
75480     } catch (...) {
75481       {
75482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75483       };
75484     }
75485   }
75486 }
75487
75488
75489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75490   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75491   unsigned int arg2 ;
75492   std::vector< Dali::Actor > *arg3 = 0 ;
75493
75494   arg1 = (Dali::Toolkit::TableView *)jarg1;
75495   arg2 = (unsigned int)jarg2;
75496   arg3 = (std::vector< Dali::Actor > *)jarg3;
75497   if (!arg3) {
75498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75499     return ;
75500   }
75501   {
75502     try {
75503       (arg1)->DeleteRow(arg2,*arg3);
75504     } catch (std::out_of_range& e) {
75505       {
75506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75507       };
75508     } catch (std::exception& e) {
75509       {
75510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75511       };
75512     } catch (...) {
75513       {
75514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75515       };
75516     }
75517   }
75518 }
75519
75520
75521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
75522   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75523   unsigned int arg2 ;
75524
75525   arg1 = (Dali::Toolkit::TableView *)jarg1;
75526   arg2 = (unsigned int)jarg2;
75527   {
75528     try {
75529       (arg1)->InsertColumn(arg2);
75530     } catch (std::out_of_range& e) {
75531       {
75532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75533       };
75534     } catch (std::exception& e) {
75535       {
75536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75537       };
75538     } catch (...) {
75539       {
75540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75541       };
75542     }
75543   }
75544 }
75545
75546
75547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
75548   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75549   unsigned int arg2 ;
75550
75551   arg1 = (Dali::Toolkit::TableView *)jarg1;
75552   arg2 = (unsigned int)jarg2;
75553   {
75554     try {
75555       (arg1)->DeleteColumn(arg2);
75556     } catch (std::out_of_range& e) {
75557       {
75558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75559       };
75560     } catch (std::exception& e) {
75561       {
75562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75563       };
75564     } catch (...) {
75565       {
75566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75567       };
75568     }
75569   }
75570 }
75571
75572
75573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75574   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75575   unsigned int arg2 ;
75576   std::vector< Dali::Actor > *arg3 = 0 ;
75577
75578   arg1 = (Dali::Toolkit::TableView *)jarg1;
75579   arg2 = (unsigned int)jarg2;
75580   arg3 = (std::vector< Dali::Actor > *)jarg3;
75581   if (!arg3) {
75582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75583     return ;
75584   }
75585   {
75586     try {
75587       (arg1)->DeleteColumn(arg2,*arg3);
75588     } catch (std::out_of_range& e) {
75589       {
75590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75591       };
75592     } catch (std::exception& e) {
75593       {
75594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75595       };
75596     } catch (...) {
75597       {
75598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75599       };
75600     }
75601   }
75602 }
75603
75604
75605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
75606   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75607   unsigned int arg2 ;
75608   unsigned int arg3 ;
75609
75610   arg1 = (Dali::Toolkit::TableView *)jarg1;
75611   arg2 = (unsigned int)jarg2;
75612   arg3 = (unsigned int)jarg3;
75613   {
75614     try {
75615       (arg1)->Resize(arg2,arg3);
75616     } catch (std::out_of_range& e) {
75617       {
75618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75619       };
75620     } catch (std::exception& e) {
75621       {
75622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75623       };
75624     } catch (...) {
75625       {
75626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75627       };
75628     }
75629   }
75630 }
75631
75632
75633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
75634   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75635   unsigned int arg2 ;
75636   unsigned int arg3 ;
75637   std::vector< Dali::Actor > *arg4 = 0 ;
75638
75639   arg1 = (Dali::Toolkit::TableView *)jarg1;
75640   arg2 = (unsigned int)jarg2;
75641   arg3 = (unsigned int)jarg3;
75642   arg4 = (std::vector< Dali::Actor > *)jarg4;
75643   if (!arg4) {
75644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75645     return ;
75646   }
75647   {
75648     try {
75649       (arg1)->Resize(arg2,arg3,*arg4);
75650     } catch (std::out_of_range& e) {
75651       {
75652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75653       };
75654     } catch (std::exception& e) {
75655       {
75656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75657       };
75658     } catch (...) {
75659       {
75660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75661       };
75662     }
75663   }
75664 }
75665
75666
75667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
75668   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75669   Dali::Size arg2 ;
75670   Dali::Size *argp2 ;
75671
75672   arg1 = (Dali::Toolkit::TableView *)jarg1;
75673   argp2 = (Dali::Size *)jarg2;
75674   if (!argp2) {
75675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
75676     return ;
75677   }
75678   arg2 = *argp2;
75679   {
75680     try {
75681       (arg1)->SetCellPadding(arg2);
75682     } catch (std::out_of_range& e) {
75683       {
75684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75685       };
75686     } catch (std::exception& e) {
75687       {
75688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75689       };
75690     } catch (...) {
75691       {
75692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75693       };
75694     }
75695   }
75696 }
75697
75698
75699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
75700   void * jresult ;
75701   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75702   Dali::Size result;
75703
75704   arg1 = (Dali::Toolkit::TableView *)jarg1;
75705   {
75706     try {
75707       result = (arg1)->GetCellPadding();
75708     } catch (std::out_of_range& e) {
75709       {
75710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75711       };
75712     } catch (std::exception& e) {
75713       {
75714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75715       };
75716     } catch (...) {
75717       {
75718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75719       };
75720     }
75721   }
75722   jresult = new Dali::Size((const Dali::Size &)result);
75723   return jresult;
75724 }
75725
75726
75727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
75728   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75729   unsigned int arg2 ;
75730
75731   arg1 = (Dali::Toolkit::TableView *)jarg1;
75732   arg2 = (unsigned int)jarg2;
75733   {
75734     try {
75735       (arg1)->SetFitHeight(arg2);
75736     } catch (std::out_of_range& e) {
75737       {
75738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75739       };
75740     } catch (std::exception& e) {
75741       {
75742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75743       };
75744     } catch (...) {
75745       {
75746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75747       };
75748     }
75749   }
75750 }
75751
75752
75753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
75754   unsigned int jresult ;
75755   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75756   unsigned int arg2 ;
75757   bool result;
75758
75759   arg1 = (Dali::Toolkit::TableView *)jarg1;
75760   arg2 = (unsigned int)jarg2;
75761   {
75762     try {
75763       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
75764     } catch (std::out_of_range& e) {
75765       {
75766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75767       };
75768     } catch (std::exception& e) {
75769       {
75770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75771       };
75772     } catch (...) {
75773       {
75774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75775       };
75776     }
75777   }
75778   jresult = result;
75779   return jresult;
75780 }
75781
75782
75783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
75784   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75785   unsigned int arg2 ;
75786
75787   arg1 = (Dali::Toolkit::TableView *)jarg1;
75788   arg2 = (unsigned int)jarg2;
75789   {
75790     try {
75791       (arg1)->SetFitWidth(arg2);
75792     } catch (std::out_of_range& e) {
75793       {
75794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75795       };
75796     } catch (std::exception& e) {
75797       {
75798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75799       };
75800     } catch (...) {
75801       {
75802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75803       };
75804     }
75805   }
75806 }
75807
75808
75809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
75810   unsigned int jresult ;
75811   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75812   unsigned int arg2 ;
75813   bool result;
75814
75815   arg1 = (Dali::Toolkit::TableView *)jarg1;
75816   arg2 = (unsigned int)jarg2;
75817   {
75818     try {
75819       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
75820     } catch (std::out_of_range& e) {
75821       {
75822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75823       };
75824     } catch (std::exception& e) {
75825       {
75826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75827       };
75828     } catch (...) {
75829       {
75830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75831       };
75832     }
75833   }
75834   jresult = result;
75835   return jresult;
75836 }
75837
75838
75839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
75840   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75841   unsigned int arg2 ;
75842   float arg3 ;
75843
75844   arg1 = (Dali::Toolkit::TableView *)jarg1;
75845   arg2 = (unsigned int)jarg2;
75846   arg3 = (float)jarg3;
75847   {
75848     try {
75849       (arg1)->SetFixedHeight(arg2,arg3);
75850     } catch (std::out_of_range& e) {
75851       {
75852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75853       };
75854     } catch (std::exception& e) {
75855       {
75856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75857       };
75858     } catch (...) {
75859       {
75860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75861       };
75862     }
75863   }
75864 }
75865
75866
75867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
75868   float jresult ;
75869   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75870   unsigned int arg2 ;
75871   float result;
75872
75873   arg1 = (Dali::Toolkit::TableView *)jarg1;
75874   arg2 = (unsigned int)jarg2;
75875   {
75876     try {
75877       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
75878     } catch (std::out_of_range& e) {
75879       {
75880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75881       };
75882     } catch (std::exception& e) {
75883       {
75884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75885       };
75886     } catch (...) {
75887       {
75888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75889       };
75890     }
75891   }
75892   jresult = result;
75893   return jresult;
75894 }
75895
75896
75897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
75898   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75899   unsigned int arg2 ;
75900   float arg3 ;
75901
75902   arg1 = (Dali::Toolkit::TableView *)jarg1;
75903   arg2 = (unsigned int)jarg2;
75904   arg3 = (float)jarg3;
75905   {
75906     try {
75907       (arg1)->SetRelativeHeight(arg2,arg3);
75908     } catch (std::out_of_range& e) {
75909       {
75910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75911       };
75912     } catch (std::exception& e) {
75913       {
75914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75915       };
75916     } catch (...) {
75917       {
75918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75919       };
75920     }
75921   }
75922 }
75923
75924
75925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
75926   float jresult ;
75927   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75928   unsigned int arg2 ;
75929   float result;
75930
75931   arg1 = (Dali::Toolkit::TableView *)jarg1;
75932   arg2 = (unsigned int)jarg2;
75933   {
75934     try {
75935       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
75936     } catch (std::out_of_range& e) {
75937       {
75938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75939       };
75940     } catch (std::exception& e) {
75941       {
75942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75943       };
75944     } catch (...) {
75945       {
75946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75947       };
75948     }
75949   }
75950   jresult = result;
75951   return jresult;
75952 }
75953
75954
75955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
75956   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75957   unsigned int arg2 ;
75958   float arg3 ;
75959
75960   arg1 = (Dali::Toolkit::TableView *)jarg1;
75961   arg2 = (unsigned int)jarg2;
75962   arg3 = (float)jarg3;
75963   {
75964     try {
75965       (arg1)->SetFixedWidth(arg2,arg3);
75966     } catch (std::out_of_range& e) {
75967       {
75968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75969       };
75970     } catch (std::exception& e) {
75971       {
75972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75973       };
75974     } catch (...) {
75975       {
75976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75977       };
75978     }
75979   }
75980 }
75981
75982
75983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
75984   float jresult ;
75985   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75986   unsigned int arg2 ;
75987   float result;
75988
75989   arg1 = (Dali::Toolkit::TableView *)jarg1;
75990   arg2 = (unsigned int)jarg2;
75991   {
75992     try {
75993       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
75994     } catch (std::out_of_range& e) {
75995       {
75996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75997       };
75998     } catch (std::exception& e) {
75999       {
76000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76001       };
76002     } catch (...) {
76003       {
76004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76005       };
76006     }
76007   }
76008   jresult = result;
76009   return jresult;
76010 }
76011
76012
76013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76014   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76015   unsigned int arg2 ;
76016   float arg3 ;
76017
76018   arg1 = (Dali::Toolkit::TableView *)jarg1;
76019   arg2 = (unsigned int)jarg2;
76020   arg3 = (float)jarg3;
76021   {
76022     try {
76023       (arg1)->SetRelativeWidth(arg2,arg3);
76024     } catch (std::out_of_range& e) {
76025       {
76026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76027       };
76028     } catch (std::exception& e) {
76029       {
76030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76031       };
76032     } catch (...) {
76033       {
76034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76035       };
76036     }
76037   }
76038 }
76039
76040
76041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76042   float jresult ;
76043   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76044   unsigned int arg2 ;
76045   float result;
76046
76047   arg1 = (Dali::Toolkit::TableView *)jarg1;
76048   arg2 = (unsigned int)jarg2;
76049   {
76050     try {
76051       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76052     } catch (std::out_of_range& e) {
76053       {
76054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76055       };
76056     } catch (std::exception& e) {
76057       {
76058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76059       };
76060     } catch (...) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76063       };
76064     }
76065   }
76066   jresult = result;
76067   return jresult;
76068 }
76069
76070
76071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76072   unsigned int jresult ;
76073   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76074   unsigned int result;
76075
76076   arg1 = (Dali::Toolkit::TableView *)jarg1;
76077   {
76078     try {
76079       result = (unsigned int)(arg1)->GetRows();
76080     } catch (std::out_of_range& e) {
76081       {
76082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76083       };
76084     } catch (std::exception& e) {
76085       {
76086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76087       };
76088     } catch (...) {
76089       {
76090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76091       };
76092     }
76093   }
76094   jresult = result;
76095   return jresult;
76096 }
76097
76098
76099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76100   unsigned int jresult ;
76101   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76102   unsigned int result;
76103
76104   arg1 = (Dali::Toolkit::TableView *)jarg1;
76105   {
76106     try {
76107       result = (unsigned int)(arg1)->GetColumns();
76108     } catch (std::out_of_range& e) {
76109       {
76110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76111       };
76112     } catch (std::exception& e) {
76113       {
76114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76115       };
76116     } catch (...) {
76117       {
76118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76119       };
76120     }
76121   }
76122   jresult = result;
76123   return jresult;
76124 }
76125
76126
76127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76128   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76129   Dali::Toolkit::TableView::CellPosition arg2 ;
76130   Dali::HorizontalAlignment::Type arg3 ;
76131   Dali::VerticalAlignment::Type arg4 ;
76132   Dali::Toolkit::TableView::CellPosition *argp2 ;
76133
76134   arg1 = (Dali::Toolkit::TableView *)jarg1;
76135   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76136   if (!argp2) {
76137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76138     return ;
76139   }
76140   arg2 = *argp2;
76141   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76142   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76143   {
76144     try {
76145       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76146     } catch (std::out_of_range& e) {
76147       {
76148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76149       };
76150     } catch (std::exception& e) {
76151       {
76152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76153       };
76154     } catch (...) {
76155       {
76156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76157       };
76158     }
76159   }
76160 }
76161
76162
76163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76164   unsigned int jresult ;
76165   unsigned int result;
76166
76167   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76168   jresult = result;
76169   return jresult;
76170 }
76171
76172
76173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76174   int jresult ;
76175   int result;
76176
76177   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76178   jresult = (int)result;
76179   return jresult;
76180 }
76181
76182
76183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76184   int jresult ;
76185   int result;
76186
76187   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76188   jresult = (int)result;
76189   return jresult;
76190 }
76191
76192
76193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76194   int jresult ;
76195   int result;
76196
76197   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76198   jresult = (int)result;
76199   return jresult;
76200 }
76201
76202
76203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76204   int jresult ;
76205   int result;
76206
76207   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76208   jresult = (int)result;
76209   return jresult;
76210 }
76211
76212
76213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76214   int jresult ;
76215   int result;
76216
76217   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76218   jresult = (int)result;
76219   return jresult;
76220 }
76221
76222
76223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76224   int jresult ;
76225   int result;
76226
76227   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76228   jresult = (int)result;
76229   return jresult;
76230 }
76231
76232
76233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76234   int jresult ;
76235   int result;
76236
76237   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76238   jresult = (int)result;
76239   return jresult;
76240 }
76241
76242
76243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76244   int jresult ;
76245   int result;
76246
76247   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76248   jresult = (int)result;
76249   return jresult;
76250 }
76251
76252
76253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76254   int jresult ;
76255   int result;
76256
76257   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76258   jresult = (int)result;
76259   return jresult;
76260 }
76261
76262
76263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76264   int jresult ;
76265   int result;
76266
76267   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76268   jresult = (int)result;
76269   return jresult;
76270 }
76271
76272
76273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76274   int jresult ;
76275   int result;
76276
76277   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76278   jresult = (int)result;
76279   return jresult;
76280 }
76281
76282
76283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76284   int jresult ;
76285   int result;
76286
76287   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76288   jresult = (int)result;
76289   return jresult;
76290 }
76291
76292
76293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76294   int jresult ;
76295   int result;
76296
76297   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76298   jresult = (int)result;
76299   return jresult;
76300 }
76301
76302
76303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76304   int jresult ;
76305   int result;
76306
76307   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76308   jresult = (int)result;
76309   return jresult;
76310 }
76311
76312
76313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76314   int jresult ;
76315   int result;
76316
76317   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76318   jresult = (int)result;
76319   return jresult;
76320 }
76321
76322
76323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76324   int jresult ;
76325   int result;
76326
76327   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76328   jresult = (int)result;
76329   return jresult;
76330 }
76331
76332
76333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76334   int jresult ;
76335   int result;
76336
76337   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76338   jresult = (int)result;
76339   return jresult;
76340 }
76341
76342
76343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76344   int jresult ;
76345   int result;
76346
76347   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76348   jresult = (int)result;
76349   return jresult;
76350 }
76351
76352
76353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76354   int jresult ;
76355   int result;
76356
76357   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76358   jresult = (int)result;
76359   return jresult;
76360 }
76361
76362
76363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76364   int jresult ;
76365   int result;
76366
76367   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76368   jresult = (int)result;
76369   return jresult;
76370 }
76371
76372
76373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76374   int jresult ;
76375   int result;
76376
76377   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76378   jresult = (int)result;
76379   return jresult;
76380 }
76381
76382
76383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76384   int jresult ;
76385   int result;
76386
76387   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76388   jresult = (int)result;
76389   return jresult;
76390 }
76391
76392
76393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76394   int jresult ;
76395   int result;
76396
76397   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76398   jresult = (int)result;
76399   return jresult;
76400 }
76401
76402
76403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
76404   int jresult ;
76405   int result;
76406
76407   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
76408   jresult = (int)result;
76409   return jresult;
76410 }
76411
76412
76413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
76414   int jresult ;
76415   int result;
76416
76417   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
76418   jresult = (int)result;
76419   return jresult;
76420 }
76421
76422
76423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
76424   int jresult ;
76425   int result;
76426
76427   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
76428   jresult = (int)result;
76429   return jresult;
76430 }
76431
76432
76433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
76434   int jresult ;
76435   int result;
76436
76437   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
76438   jresult = (int)result;
76439   return jresult;
76440 }
76441
76442
76443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
76444   int jresult ;
76445   int result;
76446
76447   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
76448   jresult = (int)result;
76449   return jresult;
76450 }
76451
76452
76453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
76454   int jresult ;
76455   int result;
76456
76457   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
76458   jresult = (int)result;
76459   return jresult;
76460 }
76461
76462
76463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
76464   int jresult ;
76465   int result;
76466
76467   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
76468   jresult = (int)result;
76469   return jresult;
76470 }
76471
76472
76473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
76474   int jresult ;
76475   int result;
76476
76477   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
76478   jresult = (int)result;
76479   return jresult;
76480 }
76481
76482
76483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
76484   int jresult ;
76485   int result;
76486
76487   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
76488   jresult = (int)result;
76489   return jresult;
76490 }
76491
76492
76493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
76494   int jresult ;
76495   int result;
76496
76497   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
76498   jresult = (int)result;
76499   return jresult;
76500 }
76501
76502
76503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
76504   int jresult ;
76505   int result;
76506
76507   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
76508   jresult = (int)result;
76509   return jresult;
76510 }
76511
76512
76513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
76514   int jresult ;
76515   int result;
76516
76517   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
76518   jresult = (int)result;
76519   return jresult;
76520 }
76521
76522
76523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
76524   int jresult ;
76525   int result;
76526
76527   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
76528   jresult = (int)result;
76529   return jresult;
76530 }
76531
76532
76533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
76534   int jresult ;
76535   int result;
76536
76537   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
76538   jresult = (int)result;
76539   return jresult;
76540 }
76541
76542
76543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
76544   int jresult ;
76545   int result;
76546
76547   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
76548   jresult = (int)result;
76549   return jresult;
76550 }
76551
76552
76553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
76554   int jresult ;
76555   int result;
76556
76557   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
76558   jresult = (int)result;
76559   return jresult;
76560 }
76561
76562
76563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
76564   int jresult ;
76565   int result;
76566
76567   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
76568   jresult = (int)result;
76569   return jresult;
76570 }
76571
76572
76573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
76574   void * jresult ;
76575   Dali::Toolkit::TextEditor::Property *result = 0 ;
76576
76577   {
76578     try {
76579       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
76580     } catch (std::out_of_range& e) {
76581       {
76582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76583       };
76584     } catch (std::exception& e) {
76585       {
76586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76587       };
76588     } catch (...) {
76589       {
76590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76591       };
76592     }
76593   }
76594   jresult = (void *)result;
76595   return jresult;
76596 }
76597
76598
76599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
76600   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
76601
76602   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
76603   {
76604     try {
76605       delete arg1;
76606     } catch (std::out_of_range& e) {
76607       {
76608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76609       };
76610     } catch (std::exception& e) {
76611       {
76612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76613       };
76614     } catch (...) {
76615       {
76616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76617       };
76618     }
76619   }
76620 }
76621
76622
76623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
76624   void * jresult ;
76625   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
76626
76627   {
76628     try {
76629       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
76630     } catch (std::out_of_range& e) {
76631       {
76632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76633       };
76634     } catch (std::exception& e) {
76635       {
76636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76637       };
76638     } catch (...) {
76639       {
76640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76641       };
76642     }
76643   }
76644   jresult = (void *)result;
76645   return jresult;
76646 }
76647
76648
76649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
76650   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
76651
76652   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
76653   {
76654     try {
76655       delete arg1;
76656     } catch (std::out_of_range& e) {
76657       {
76658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76659       };
76660     } catch (std::exception& e) {
76661       {
76662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76663       };
76664     } catch (...) {
76665       {
76666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76667       };
76668     }
76669   }
76670 }
76671
76672
76673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
76674   void * jresult ;
76675   Dali::Toolkit::TextEditor result;
76676
76677   {
76678     try {
76679       result = Dali::Toolkit::TextEditor::New();
76680     } catch (std::out_of_range& e) {
76681       {
76682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76683       };
76684     } catch (std::exception& e) {
76685       {
76686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76687       };
76688     } catch (...) {
76689       {
76690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76691       };
76692     }
76693   }
76694   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
76695   return jresult;
76696 }
76697
76698
76699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
76700   void * jresult ;
76701   Dali::Toolkit::TextEditor *result = 0 ;
76702
76703   {
76704     try {
76705       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
76706     } catch (std::out_of_range& e) {
76707       {
76708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76709       };
76710     } catch (std::exception& e) {
76711       {
76712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76713       };
76714     } catch (...) {
76715       {
76716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76717       };
76718     }
76719   }
76720   jresult = (void *)result;
76721   return jresult;
76722 }
76723
76724
76725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
76726   void * jresult ;
76727   Dali::Toolkit::TextEditor *arg1 = 0 ;
76728   Dali::Toolkit::TextEditor *result = 0 ;
76729
76730   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76731   if (!arg1) {
76732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
76733     return 0;
76734   }
76735   {
76736     try {
76737       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
76738     } catch (std::out_of_range& e) {
76739       {
76740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76741       };
76742     } catch (std::exception& e) {
76743       {
76744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76745       };
76746     } catch (...) {
76747       {
76748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76749       };
76750     }
76751   }
76752   jresult = (void *)result;
76753   return jresult;
76754 }
76755
76756
76757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
76758   void * jresult ;
76759   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
76760   Dali::Toolkit::TextEditor *arg2 = 0 ;
76761   Dali::Toolkit::TextEditor *result = 0 ;
76762
76763   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76764   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
76765   if (!arg2) {
76766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
76767     return 0;
76768   }
76769   {
76770     try {
76771       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
76772     } catch (std::out_of_range& e) {
76773       {
76774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76775       };
76776     } catch (std::exception& e) {
76777       {
76778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76779       };
76780     } catch (...) {
76781       {
76782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76783       };
76784     }
76785   }
76786   jresult = (void *)result;
76787   return jresult;
76788 }
76789
76790
76791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
76792   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
76793
76794   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76795   {
76796     try {
76797       delete arg1;
76798     } catch (std::out_of_range& e) {
76799       {
76800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76801       };
76802     } catch (std::exception& e) {
76803       {
76804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76805       };
76806     } catch (...) {
76807       {
76808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76809       };
76810     }
76811   }
76812 }
76813
76814
76815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
76816   void * jresult ;
76817   Dali::BaseHandle arg1 ;
76818   Dali::BaseHandle *argp1 ;
76819   Dali::Toolkit::TextEditor result;
76820
76821   argp1 = (Dali::BaseHandle *)jarg1;
76822   if (!argp1) {
76823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76824     return 0;
76825   }
76826   arg1 = *argp1;
76827   {
76828     try {
76829       result = Dali::Toolkit::TextEditor::DownCast(arg1);
76830     } catch (std::out_of_range& e) {
76831       {
76832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76833       };
76834     } catch (std::exception& e) {
76835       {
76836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76837       };
76838     } catch (...) {
76839       {
76840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76841       };
76842     }
76843   }
76844   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
76845   return jresult;
76846 }
76847
76848
76849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
76850   void * jresult ;
76851   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
76852   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
76853
76854   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76855   {
76856     try {
76857       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
76858     } catch (std::out_of_range& e) {
76859       {
76860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76861       };
76862     } catch (std::exception& e) {
76863       {
76864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76865       };
76866     } catch (...) {
76867       {
76868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76869       };
76870     }
76871   }
76872   jresult = (void *)result;
76873   return jresult;
76874 }
76875
76876
76877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
76878   void * jresult ;
76879   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
76880   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
76881
76882   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76883   {
76884     try {
76885       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
76886     } catch (std::out_of_range& e) {
76887       {
76888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76889       };
76890     } catch (std::exception& e) {
76891       {
76892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76893       };
76894     } catch (...) {
76895       {
76896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76897       };
76898     }
76899   }
76900   jresult = (void *)result;
76901   return jresult;
76902 }
76903
76904
76905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
76906   int jresult ;
76907   int result;
76908
76909   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
76910   jresult = (int)result;
76911   return jresult;
76912 }
76913
76914
76915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
76916   int jresult ;
76917   int result;
76918
76919   result = (int)Dali::Toolkit::TextField::Property::TEXT;
76920   jresult = (int)result;
76921   return jresult;
76922 }
76923
76924
76925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
76926   int jresult ;
76927   int result;
76928
76929   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
76930   jresult = (int)result;
76931   return jresult;
76932 }
76933
76934
76935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
76936   int jresult ;
76937   int result;
76938
76939   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
76940   jresult = (int)result;
76941   return jresult;
76942 }
76943
76944
76945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
76946   int jresult ;
76947   int result;
76948
76949   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
76950   jresult = (int)result;
76951   return jresult;
76952 }
76953
76954
76955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
76956   int jresult ;
76957   int result;
76958
76959   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
76960   jresult = (int)result;
76961   return jresult;
76962 }
76963
76964
76965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
76966   int jresult ;
76967   int result;
76968
76969   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
76970   jresult = (int)result;
76971   return jresult;
76972 }
76973
76974
76975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
76976   int jresult ;
76977   int result;
76978
76979   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
76980   jresult = (int)result;
76981   return jresult;
76982 }
76983
76984
76985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
76986   int jresult ;
76987   int result;
76988
76989   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
76990   jresult = (int)result;
76991   return jresult;
76992 }
76993
76994
76995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
76996   int jresult ;
76997   int result;
76998
76999   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77000   jresult = (int)result;
77001   return jresult;
77002 }
77003
77004
77005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77006   int jresult ;
77007   int result;
77008
77009   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77010   jresult = (int)result;
77011   return jresult;
77012 }
77013
77014
77015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77016   int jresult ;
77017   int result;
77018
77019   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77020   jresult = (int)result;
77021   return jresult;
77022 }
77023
77024
77025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77026   int jresult ;
77027   int result;
77028
77029   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77030   jresult = (int)result;
77031   return jresult;
77032 }
77033
77034
77035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77036   int jresult ;
77037   int result;
77038
77039   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77040   jresult = (int)result;
77041   return jresult;
77042 }
77043
77044
77045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77046   int jresult ;
77047   int result;
77048
77049   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77050   jresult = (int)result;
77051   return jresult;
77052 }
77053
77054
77055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77056   int jresult ;
77057   int result;
77058
77059   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77060   jresult = (int)result;
77061   return jresult;
77062 }
77063
77064
77065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77066   int jresult ;
77067   int result;
77068
77069   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77070   jresult = (int)result;
77071   return jresult;
77072 }
77073
77074
77075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77076   int jresult ;
77077   int result;
77078
77079   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77080   jresult = (int)result;
77081   return jresult;
77082 }
77083
77084
77085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77086   int jresult ;
77087   int result;
77088
77089   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77090   jresult = (int)result;
77091   return jresult;
77092 }
77093
77094
77095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77096   int jresult ;
77097   int result;
77098
77099   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77100   jresult = (int)result;
77101   return jresult;
77102 }
77103
77104
77105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77106   int jresult ;
77107   int result;
77108
77109   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77110   jresult = (int)result;
77111   return jresult;
77112 }
77113
77114
77115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77116   int jresult ;
77117   int result;
77118
77119   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77120   jresult = (int)result;
77121   return jresult;
77122 }
77123
77124
77125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77126   int jresult ;
77127   int result;
77128
77129   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77130   jresult = (int)result;
77131   return jresult;
77132 }
77133
77134
77135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77136   int jresult ;
77137   int result;
77138
77139   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77140   jresult = (int)result;
77141   return jresult;
77142 }
77143
77144
77145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77146   int jresult ;
77147   int result;
77148
77149   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77150   jresult = (int)result;
77151   return jresult;
77152 }
77153
77154
77155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77156   int jresult ;
77157   int result;
77158
77159   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77160   jresult = (int)result;
77161   return jresult;
77162 }
77163
77164
77165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77166   int jresult ;
77167   int result;
77168
77169   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77170   jresult = (int)result;
77171   return jresult;
77172 }
77173
77174
77175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77176   int jresult ;
77177   int result;
77178
77179   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77180   jresult = (int)result;
77181   return jresult;
77182 }
77183
77184
77185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77186   int jresult ;
77187   int result;
77188
77189   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77190   jresult = (int)result;
77191   return jresult;
77192 }
77193
77194
77195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77196   int jresult ;
77197   int result;
77198
77199   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77200   jresult = (int)result;
77201   return jresult;
77202 }
77203
77204
77205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77206   int jresult ;
77207   int result;
77208
77209   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77210   jresult = (int)result;
77211   return jresult;
77212 }
77213
77214
77215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77216   int jresult ;
77217   int result;
77218
77219   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77220   jresult = (int)result;
77221   return jresult;
77222 }
77223
77224
77225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77226   int jresult ;
77227   int result;
77228
77229   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77230   jresult = (int)result;
77231   return jresult;
77232 }
77233
77234
77235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77236   int jresult ;
77237   int result;
77238
77239   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77240   jresult = (int)result;
77241   return jresult;
77242 }
77243
77244
77245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77246   int jresult ;
77247   int result;
77248
77249   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77250   jresult = (int)result;
77251   return jresult;
77252 }
77253
77254
77255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77256   int jresult ;
77257   int result;
77258
77259   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77260   jresult = (int)result;
77261   return jresult;
77262 }
77263
77264
77265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77266   int jresult ;
77267   int result;
77268
77269   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77270   jresult = (int)result;
77271   return jresult;
77272 }
77273
77274
77275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77276   int jresult ;
77277   int result;
77278
77279   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77280   jresult = (int)result;
77281   return jresult;
77282 }
77283
77284
77285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77286   int jresult ;
77287   int result;
77288
77289   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77290   jresult = (int)result;
77291   return jresult;
77292 }
77293
77294
77295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77296   int jresult ;
77297   int result;
77298
77299   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77300   jresult = (int)result;
77301   return jresult;
77302 }
77303
77304
77305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77306   int jresult ;
77307   int result;
77308
77309   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77310   jresult = (int)result;
77311   return jresult;
77312 }
77313
77314
77315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77316   int jresult ;
77317   int result;
77318
77319   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77320   jresult = (int)result;
77321   return jresult;
77322 }
77323
77324
77325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77326   int jresult ;
77327   int result;
77328
77329   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77330   jresult = (int)result;
77331   return jresult;
77332 }
77333
77334
77335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77336   int jresult ;
77337   int result;
77338
77339   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77340   jresult = (int)result;
77341   return jresult;
77342 }
77343
77344
77345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77346   int jresult ;
77347   int result;
77348
77349   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77350   jresult = (int)result;
77351   return jresult;
77352 }
77353
77354
77355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77356   int jresult ;
77357   int result;
77358
77359   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77360   jresult = (int)result;
77361   return jresult;
77362 }
77363
77364
77365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77366   int jresult ;
77367   int result;
77368
77369   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77370   jresult = (int)result;
77371   return jresult;
77372 }
77373
77374
77375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77376   void * jresult ;
77377   Dali::Toolkit::TextField::Property *result = 0 ;
77378
77379   {
77380     try {
77381       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77382     } catch (std::out_of_range& e) {
77383       {
77384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77385       };
77386     } catch (std::exception& e) {
77387       {
77388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77389       };
77390     } catch (...) {
77391       {
77392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77393       };
77394     }
77395   }
77396   jresult = (void *)result;
77397   return jresult;
77398 }
77399
77400
77401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77402   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77403
77404   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
77405   {
77406     try {
77407       delete arg1;
77408     } catch (std::out_of_range& e) {
77409       {
77410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77411       };
77412     } catch (std::exception& e) {
77413       {
77414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77415       };
77416     } catch (...) {
77417       {
77418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77419       };
77420     }
77421   }
77422 }
77423
77424
77425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
77426   void * jresult ;
77427   Dali::Toolkit::TextField::InputStyle *result = 0 ;
77428
77429   {
77430     try {
77431       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
77432     } catch (std::out_of_range& e) {
77433       {
77434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77435       };
77436     } catch (std::exception& e) {
77437       {
77438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77439       };
77440     } catch (...) {
77441       {
77442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77443       };
77444     }
77445   }
77446   jresult = (void *)result;
77447   return jresult;
77448 }
77449
77450
77451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
77452   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
77453
77454   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
77455   {
77456     try {
77457       delete arg1;
77458     } catch (std::out_of_range& e) {
77459       {
77460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77461       };
77462     } catch (std::exception& e) {
77463       {
77464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77465       };
77466     } catch (...) {
77467       {
77468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77469       };
77470     }
77471   }
77472 }
77473
77474
77475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
77476   void * jresult ;
77477   Dali::Toolkit::TextField result;
77478
77479   {
77480     try {
77481       result = Dali::Toolkit::TextField::New();
77482     } catch (std::out_of_range& e) {
77483       {
77484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77485       };
77486     } catch (std::exception& e) {
77487       {
77488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77489       };
77490     } catch (...) {
77491       {
77492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77493       };
77494     }
77495   }
77496   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77497   return jresult;
77498 }
77499
77500
77501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
77502   void * jresult ;
77503   Dali::Toolkit::TextField *result = 0 ;
77504
77505   {
77506     try {
77507       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
77508     } catch (std::out_of_range& e) {
77509       {
77510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77511       };
77512     } catch (std::exception& e) {
77513       {
77514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77515       };
77516     } catch (...) {
77517       {
77518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77519       };
77520     }
77521   }
77522   jresult = (void *)result;
77523   return jresult;
77524 }
77525
77526
77527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
77528   void * jresult ;
77529   Dali::Toolkit::TextField *arg1 = 0 ;
77530   Dali::Toolkit::TextField *result = 0 ;
77531
77532   arg1 = (Dali::Toolkit::TextField *)jarg1;
77533   if (!arg1) {
77534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77535     return 0;
77536   }
77537   {
77538     try {
77539       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
77540     } catch (std::out_of_range& e) {
77541       {
77542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77543       };
77544     } catch (std::exception& e) {
77545       {
77546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77547       };
77548     } catch (...) {
77549       {
77550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77551       };
77552     }
77553   }
77554   jresult = (void *)result;
77555   return jresult;
77556 }
77557
77558
77559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
77560   void * jresult ;
77561   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77562   Dali::Toolkit::TextField *arg2 = 0 ;
77563   Dali::Toolkit::TextField *result = 0 ;
77564
77565   arg1 = (Dali::Toolkit::TextField *)jarg1;
77566   arg2 = (Dali::Toolkit::TextField *)jarg2;
77567   if (!arg2) {
77568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77569     return 0;
77570   }
77571   {
77572     try {
77573       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
77574     } catch (std::out_of_range& e) {
77575       {
77576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77577       };
77578     } catch (std::exception& e) {
77579       {
77580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77581       };
77582     } catch (...) {
77583       {
77584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77585       };
77586     }
77587   }
77588   jresult = (void *)result;
77589   return jresult;
77590 }
77591
77592
77593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
77594   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77595
77596   arg1 = (Dali::Toolkit::TextField *)jarg1;
77597   {
77598     try {
77599       delete arg1;
77600     } catch (std::out_of_range& e) {
77601       {
77602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77603       };
77604     } catch (std::exception& e) {
77605       {
77606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77607       };
77608     } catch (...) {
77609       {
77610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77611       };
77612     }
77613   }
77614 }
77615
77616
77617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
77618   void * jresult ;
77619   Dali::BaseHandle arg1 ;
77620   Dali::BaseHandle *argp1 ;
77621   Dali::Toolkit::TextField result;
77622
77623   argp1 = (Dali::BaseHandle *)jarg1;
77624   if (!argp1) {
77625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77626     return 0;
77627   }
77628   arg1 = *argp1;
77629   {
77630     try {
77631       result = Dali::Toolkit::TextField::DownCast(arg1);
77632     } catch (std::out_of_range& e) {
77633       {
77634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77635       };
77636     } catch (std::exception& e) {
77637       {
77638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77639       };
77640     } catch (...) {
77641       {
77642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77643       };
77644     }
77645   }
77646   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77647   return jresult;
77648 }
77649
77650
77651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
77652   void * jresult ;
77653   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77654   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
77655
77656   arg1 = (Dali::Toolkit::TextField *)jarg1;
77657   {
77658     try {
77659       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77660     } catch (std::out_of_range& e) {
77661       {
77662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77663       };
77664     } catch (std::exception& e) {
77665       {
77666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77667       };
77668     } catch (...) {
77669       {
77670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77671       };
77672     }
77673   }
77674   jresult = (void *)result;
77675   return jresult;
77676 }
77677
77678
77679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
77680   void * jresult ;
77681   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77682   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
77683
77684   arg1 = (Dali::Toolkit::TextField *)jarg1;
77685   {
77686     try {
77687       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
77688     } catch (std::out_of_range& e) {
77689       {
77690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77691       };
77692     } catch (std::exception& e) {
77693       {
77694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77695       };
77696     } catch (...) {
77697       {
77698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77699       };
77700     }
77701   }
77702   jresult = (void *)result;
77703   return jresult;
77704 }
77705
77706
77707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
77708   void * jresult ;
77709   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77710   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
77711
77712   arg1 = (Dali::Toolkit::TextField *)jarg1;
77713   {
77714     try {
77715       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77716     } catch (std::out_of_range& e) {
77717       {
77718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77719       };
77720     } catch (std::exception& e) {
77721       {
77722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77723       };
77724     } catch (...) {
77725       {
77726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77727       };
77728     }
77729   }
77730   jresult = (void *)result;
77731   return jresult;
77732 }
77733
77734
77735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
77736   int jresult ;
77737   int result;
77738
77739   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
77740   jresult = (int)result;
77741   return jresult;
77742 }
77743
77744
77745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
77746   int jresult ;
77747   int result;
77748
77749   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
77750   jresult = (int)result;
77751   return jresult;
77752 }
77753
77754
77755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
77756   int jresult ;
77757   int result;
77758
77759   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
77760   jresult = (int)result;
77761   return jresult;
77762 }
77763
77764
77765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
77766   int jresult ;
77767   int result;
77768
77769   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
77770   jresult = (int)result;
77771   return jresult;
77772 }
77773
77774
77775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
77776   int jresult ;
77777   int result;
77778
77779   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
77780   jresult = (int)result;
77781   return jresult;
77782 }
77783
77784
77785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
77786   int jresult ;
77787   int result;
77788
77789   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
77790   jresult = (int)result;
77791   return jresult;
77792 }
77793
77794
77795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
77796   int jresult ;
77797   int result;
77798
77799   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
77800   jresult = (int)result;
77801   return jresult;
77802 }
77803
77804
77805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
77806   int jresult ;
77807   int result;
77808
77809   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
77810   jresult = (int)result;
77811   return jresult;
77812 }
77813
77814
77815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
77816   int jresult ;
77817   int result;
77818
77819   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
77820   jresult = (int)result;
77821   return jresult;
77822 }
77823
77824
77825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
77826   int jresult ;
77827   int result;
77828
77829   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
77830   jresult = (int)result;
77831   return jresult;
77832 }
77833
77834
77835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
77836   int jresult ;
77837   int result;
77838
77839   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
77840   jresult = (int)result;
77841   return jresult;
77842 }
77843
77844
77845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
77846   int jresult ;
77847   int result;
77848
77849   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
77850   jresult = (int)result;
77851   return jresult;
77852 }
77853
77854
77855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
77856   int jresult ;
77857   int result;
77858
77859   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
77860   jresult = (int)result;
77861   return jresult;
77862 }
77863
77864
77865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
77866   int jresult ;
77867   int result;
77868
77869   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
77870   jresult = (int)result;
77871   return jresult;
77872 }
77873
77874
77875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
77876   int jresult ;
77877   int result;
77878
77879   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
77880   jresult = (int)result;
77881   return jresult;
77882 }
77883
77884
77885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
77886   int jresult ;
77887   int result;
77888
77889   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
77890   jresult = (int)result;
77891   return jresult;
77892 }
77893
77894
77895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
77896   int jresult ;
77897   int result;
77898
77899   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
77900   jresult = (int)result;
77901   return jresult;
77902 }
77903
77904
77905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
77906   int jresult ;
77907   int result;
77908
77909   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
77910   jresult = (int)result;
77911   return jresult;
77912 }
77913
77914
77915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
77916   int jresult ;
77917   int result;
77918
77919   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
77920   jresult = (int)result;
77921   return jresult;
77922 }
77923
77924
77925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
77926   int jresult ;
77927   int result;
77928
77929   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
77930   jresult = (int)result;
77931   return jresult;
77932 }
77933
77934
77935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
77936   int jresult ;
77937   int result;
77938
77939   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
77940   jresult = (int)result;
77941   return jresult;
77942 }
77943
77944
77945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
77946   int jresult ;
77947   int result;
77948
77949   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
77950   jresult = (int)result;
77951   return jresult;
77952 }
77953
77954
77955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
77956   int jresult ;
77957   int result;
77958
77959   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
77960   jresult = (int)result;
77961   return jresult;
77962 }
77963
77964
77965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
77966   int jresult ;
77967   int result;
77968
77969   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
77970   jresult = (int)result;
77971   return jresult;
77972 }
77973
77974
77975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
77976   void * jresult ;
77977   Dali::Toolkit::TextLabel::Property *result = 0 ;
77978
77979   {
77980     try {
77981       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
77982     } catch (std::out_of_range& e) {
77983       {
77984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77985       };
77986     } catch (std::exception& e) {
77987       {
77988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77989       };
77990     } catch (...) {
77991       {
77992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77993       };
77994     }
77995   }
77996   jresult = (void *)result;
77997   return jresult;
77998 }
77999
78000
78001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78002   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78003
78004   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78005   {
78006     try {
78007       delete arg1;
78008     } catch (std::out_of_range& e) {
78009       {
78010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78011       };
78012     } catch (std::exception& e) {
78013       {
78014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78015       };
78016     } catch (...) {
78017       {
78018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78019       };
78020     }
78021   }
78022 }
78023
78024
78025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78026   void * jresult ;
78027   Dali::Toolkit::TextLabel result;
78028
78029   {
78030     try {
78031       result = Dali::Toolkit::TextLabel::New();
78032     } catch (std::out_of_range& e) {
78033       {
78034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78035       };
78036     } catch (std::exception& e) {
78037       {
78038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78039       };
78040     } catch (...) {
78041       {
78042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78043       };
78044     }
78045   }
78046   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78047   return jresult;
78048 }
78049
78050
78051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78052   void * jresult ;
78053   std::string *arg1 = 0 ;
78054   Dali::Toolkit::TextLabel result;
78055
78056   if (!jarg1) {
78057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78058     return 0;
78059   }
78060   std::string arg1_str(jarg1);
78061   arg1 = &arg1_str;
78062   {
78063     try {
78064       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78065     } catch (std::out_of_range& e) {
78066       {
78067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78068       };
78069     } catch (std::exception& e) {
78070       {
78071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78072       };
78073     } catch (...) {
78074       {
78075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78076       };
78077     }
78078   }
78079   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78080
78081   //argout typemap for const std::string&
78082
78083   return jresult;
78084 }
78085
78086
78087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78088   void * jresult ;
78089   Dali::Toolkit::TextLabel *result = 0 ;
78090
78091   {
78092     try {
78093       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78094     } catch (std::out_of_range& e) {
78095       {
78096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78097       };
78098     } catch (std::exception& e) {
78099       {
78100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78101       };
78102     } catch (...) {
78103       {
78104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78105       };
78106     }
78107   }
78108   jresult = (void *)result;
78109   return jresult;
78110 }
78111
78112
78113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78114   void * jresult ;
78115   Dali::Toolkit::TextLabel *arg1 = 0 ;
78116   Dali::Toolkit::TextLabel *result = 0 ;
78117
78118   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78119   if (!arg1) {
78120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78121     return 0;
78122   }
78123   {
78124     try {
78125       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78126     } catch (std::out_of_range& e) {
78127       {
78128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78129       };
78130     } catch (std::exception& e) {
78131       {
78132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78133       };
78134     } catch (...) {
78135       {
78136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78137       };
78138     }
78139   }
78140   jresult = (void *)result;
78141   return jresult;
78142 }
78143
78144
78145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78146   void * jresult ;
78147   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78148   Dali::Toolkit::TextLabel *arg2 = 0 ;
78149   Dali::Toolkit::TextLabel *result = 0 ;
78150
78151   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78152   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78153   if (!arg2) {
78154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78155     return 0;
78156   }
78157   {
78158     try {
78159       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78160     } catch (std::out_of_range& e) {
78161       {
78162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78163       };
78164     } catch (std::exception& e) {
78165       {
78166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78167       };
78168     } catch (...) {
78169       {
78170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78171       };
78172     }
78173   }
78174   jresult = (void *)result;
78175   return jresult;
78176 }
78177
78178
78179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78180   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78181
78182   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78183   {
78184     try {
78185       delete arg1;
78186     } catch (std::out_of_range& e) {
78187       {
78188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78189       };
78190     } catch (std::exception& e) {
78191       {
78192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78193       };
78194     } catch (...) {
78195       {
78196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78197       };
78198     }
78199   }
78200 }
78201
78202
78203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78204   void * jresult ;
78205   Dali::BaseHandle arg1 ;
78206   Dali::BaseHandle *argp1 ;
78207   Dali::Toolkit::TextLabel result;
78208
78209   argp1 = (Dali::BaseHandle *)jarg1;
78210   if (!argp1) {
78211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78212     return 0;
78213   }
78214   arg1 = *argp1;
78215   {
78216     try {
78217       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78218     } catch (std::out_of_range& e) {
78219       {
78220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78221       };
78222     } catch (std::exception& e) {
78223       {
78224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78225       };
78226     } catch (...) {
78227       {
78228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78229       };
78230     }
78231   }
78232   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78233   return jresult;
78234 }
78235
78236
78237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78238   void * jresult ;
78239   Dali::Toolkit::AccessibilityManager *result = 0 ;
78240
78241   {
78242     try {
78243       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78244     } catch (std::out_of_range& e) {
78245       {
78246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78247       };
78248     } catch (std::exception& e) {
78249       {
78250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78251       };
78252     } catch (...) {
78253       {
78254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78255       };
78256     }
78257   }
78258   jresult = (void *)result;
78259   return jresult;
78260 }
78261
78262
78263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78264   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78265
78266   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78267   {
78268     try {
78269       delete arg1;
78270     } catch (std::out_of_range& e) {
78271       {
78272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78273       };
78274     } catch (std::exception& e) {
78275       {
78276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78277       };
78278     } catch (...) {
78279       {
78280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78281       };
78282     }
78283   }
78284 }
78285
78286
78287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78288   void * jresult ;
78289   Dali::Toolkit::AccessibilityManager result;
78290
78291   {
78292     try {
78293       result = Dali::Toolkit::AccessibilityManager::Get();
78294     } catch (std::out_of_range& e) {
78295       {
78296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78297       };
78298     } catch (std::exception& e) {
78299       {
78300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78301       };
78302     } catch (...) {
78303       {
78304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78305       };
78306     }
78307   }
78308   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78309   return jresult;
78310 }
78311
78312
78313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78314   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78315   Dali::Actor arg2 ;
78316   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78317   std::string *arg4 = 0 ;
78318   Dali::Actor *argp2 ;
78319
78320   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78321   argp2 = (Dali::Actor *)jarg2;
78322   if (!argp2) {
78323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78324     return ;
78325   }
78326   arg2 = *argp2;
78327   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78328   if (!jarg4) {
78329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78330     return ;
78331   }
78332   std::string arg4_str(jarg4);
78333   arg4 = &arg4_str;
78334   {
78335     try {
78336       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78337     } catch (std::out_of_range& e) {
78338       {
78339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78340       };
78341     } catch (std::exception& e) {
78342       {
78343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78344       };
78345     } catch (...) {
78346       {
78347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78348       };
78349     }
78350   }
78351
78352   //argout typemap for const std::string&
78353
78354 }
78355
78356
78357 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78358   char * jresult ;
78359   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78360   Dali::Actor arg2 ;
78361   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78362   Dali::Actor *argp2 ;
78363   std::string result;
78364
78365   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78366   argp2 = (Dali::Actor *)jarg2;
78367   if (!argp2) {
78368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78369     return 0;
78370   }
78371   arg2 = *argp2;
78372   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78373   {
78374     try {
78375       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78376     } catch (std::out_of_range& e) {
78377       {
78378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78379       };
78380     } catch (std::exception& e) {
78381       {
78382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78383       };
78384     } catch (...) {
78385       {
78386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78387       };
78388     }
78389   }
78390   jresult = SWIG_csharp_string_callback((&result)->c_str());
78391   return jresult;
78392 }
78393
78394
78395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78396   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78397   Dali::Actor arg2 ;
78398   unsigned int arg3 ;
78399   Dali::Actor *argp2 ;
78400
78401   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78402   argp2 = (Dali::Actor *)jarg2;
78403   if (!argp2) {
78404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78405     return ;
78406   }
78407   arg2 = *argp2;
78408   arg3 = (unsigned int)jarg3;
78409   {
78410     try {
78411       (arg1)->SetFocusOrder(arg2,arg3);
78412     } catch (std::out_of_range& e) {
78413       {
78414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78415       };
78416     } catch (std::exception& e) {
78417       {
78418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78419       };
78420     } catch (...) {
78421       {
78422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78423       };
78424     }
78425   }
78426 }
78427
78428
78429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78430   unsigned int jresult ;
78431   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78432   Dali::Actor arg2 ;
78433   Dali::Actor *argp2 ;
78434   unsigned int result;
78435
78436   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78437   argp2 = (Dali::Actor *)jarg2;
78438   if (!argp2) {
78439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78440     return 0;
78441   }
78442   arg2 = *argp2;
78443   {
78444     try {
78445       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78446     } catch (std::out_of_range& e) {
78447       {
78448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78449       };
78450     } catch (std::exception& e) {
78451       {
78452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78453       };
78454     } catch (...) {
78455       {
78456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78457       };
78458     }
78459   }
78460   jresult = result;
78461   return jresult;
78462 }
78463
78464
78465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78466   unsigned int jresult ;
78467   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78468   unsigned int result;
78469
78470   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78471   {
78472     try {
78473       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78474     } catch (std::out_of_range& e) {
78475       {
78476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78477       };
78478     } catch (std::exception& e) {
78479       {
78480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78481       };
78482     } catch (...) {
78483       {
78484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78485       };
78486     }
78487   }
78488   jresult = result;
78489   return jresult;
78490 }
78491
78492
78493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
78494   void * jresult ;
78495   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78496   unsigned int arg2 ;
78497   Dali::Actor result;
78498
78499   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78500   arg2 = (unsigned int)jarg2;
78501   {
78502     try {
78503       result = (arg1)->GetActorByFocusOrder(arg2);
78504     } catch (std::out_of_range& e) {
78505       {
78506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78507       };
78508     } catch (std::exception& e) {
78509       {
78510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78511       };
78512     } catch (...) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78515       };
78516     }
78517   }
78518   jresult = new Dali::Actor((const Dali::Actor &)result);
78519   return jresult;
78520 }
78521
78522
78523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
78524   unsigned int jresult ;
78525   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78526   Dali::Actor arg2 ;
78527   Dali::Actor *argp2 ;
78528   bool result;
78529
78530   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78531   argp2 = (Dali::Actor *)jarg2;
78532   if (!argp2) {
78533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78534     return 0;
78535   }
78536   arg2 = *argp2;
78537   {
78538     try {
78539       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
78540     } catch (std::out_of_range& e) {
78541       {
78542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78543       };
78544     } catch (std::exception& e) {
78545       {
78546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78547       };
78548     } catch (...) {
78549       {
78550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78551       };
78552     }
78553   }
78554   jresult = result;
78555   return jresult;
78556 }
78557
78558
78559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
78560   void * jresult ;
78561   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78562   Dali::Actor result;
78563
78564   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78565   {
78566     try {
78567       result = (arg1)->GetCurrentFocusActor();
78568     } catch (std::out_of_range& e) {
78569       {
78570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78571       };
78572     } catch (std::exception& e) {
78573       {
78574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78575       };
78576     } catch (...) {
78577       {
78578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78579       };
78580     }
78581   }
78582   jresult = new Dali::Actor((const Dali::Actor &)result);
78583   return jresult;
78584 }
78585
78586
78587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
78588   void * jresult ;
78589   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78590   Dali::Actor result;
78591
78592   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78593   {
78594     try {
78595       result = (arg1)->GetCurrentFocusGroup();
78596     } catch (std::out_of_range& e) {
78597       {
78598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78599       };
78600     } catch (std::exception& e) {
78601       {
78602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78603       };
78604     } catch (...) {
78605       {
78606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78607       };
78608     }
78609   }
78610   jresult = new Dali::Actor((const Dali::Actor &)result);
78611   return jresult;
78612 }
78613
78614
78615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
78616   unsigned int jresult ;
78617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78618   unsigned int result;
78619
78620   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78621   {
78622     try {
78623       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
78624     } catch (std::out_of_range& e) {
78625       {
78626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78627       };
78628     } catch (std::exception& e) {
78629       {
78630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78631       };
78632     } catch (...) {
78633       {
78634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78635       };
78636     }
78637   }
78638   jresult = result;
78639   return jresult;
78640 }
78641
78642
78643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
78644   unsigned int jresult ;
78645   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78646   bool result;
78647
78648   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78649   {
78650     try {
78651       result = (bool)(arg1)->MoveFocusForward();
78652     } catch (std::out_of_range& e) {
78653       {
78654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78655       };
78656     } catch (std::exception& e) {
78657       {
78658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78659       };
78660     } catch (...) {
78661       {
78662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78663       };
78664     }
78665   }
78666   jresult = result;
78667   return jresult;
78668 }
78669
78670
78671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
78672   unsigned int jresult ;
78673   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78674   bool result;
78675
78676   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78677   {
78678     try {
78679       result = (bool)(arg1)->MoveFocusBackward();
78680     } catch (std::out_of_range& e) {
78681       {
78682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78683       };
78684     } catch (std::exception& e) {
78685       {
78686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78687       };
78688     } catch (...) {
78689       {
78690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78691       };
78692     }
78693   }
78694   jresult = result;
78695   return jresult;
78696 }
78697
78698
78699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
78700   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78701
78702   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78703   {
78704     try {
78705       (arg1)->ClearFocus();
78706     } catch (std::out_of_range& e) {
78707       {
78708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78709       };
78710     } catch (std::exception& e) {
78711       {
78712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78713       };
78714     } catch (...) {
78715       {
78716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78717       };
78718     }
78719   }
78720 }
78721
78722
78723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
78724   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78725
78726   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78727   {
78728     try {
78729       (arg1)->Reset();
78730     } catch (std::out_of_range& e) {
78731       {
78732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78733       };
78734     } catch (std::exception& e) {
78735       {
78736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78737       };
78738     } catch (...) {
78739       {
78740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78741       };
78742     }
78743   }
78744 }
78745
78746
78747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
78748   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78749   Dali::Actor arg2 ;
78750   bool arg3 ;
78751   Dali::Actor *argp2 ;
78752
78753   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78754   argp2 = (Dali::Actor *)jarg2;
78755   if (!argp2) {
78756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78757     return ;
78758   }
78759   arg2 = *argp2;
78760   arg3 = jarg3 ? true : false;
78761   {
78762     try {
78763       (arg1)->SetFocusGroup(arg2,arg3);
78764     } catch (std::out_of_range& e) {
78765       {
78766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78767       };
78768     } catch (std::exception& e) {
78769       {
78770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78771       };
78772     } catch (...) {
78773       {
78774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78775       };
78776     }
78777   }
78778 }
78779
78780
78781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
78782   unsigned int jresult ;
78783   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78784   Dali::Actor arg2 ;
78785   Dali::Actor *argp2 ;
78786   bool result;
78787
78788   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78789   argp2 = (Dali::Actor *)jarg2;
78790   if (!argp2) {
78791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78792     return 0;
78793   }
78794   arg2 = *argp2;
78795   {
78796     try {
78797       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
78798     } catch (std::out_of_range& e) {
78799       {
78800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78801       };
78802     } catch (std::exception& e) {
78803       {
78804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78805       };
78806     } catch (...) {
78807       {
78808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78809       };
78810     }
78811   }
78812   jresult = result;
78813   return jresult;
78814 }
78815
78816
78817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
78818   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78819   bool arg2 ;
78820
78821   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78822   arg2 = jarg2 ? true : false;
78823   {
78824     try {
78825       (arg1)->SetGroupMode(arg2);
78826     } catch (std::out_of_range& e) {
78827       {
78828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78829       };
78830     } catch (std::exception& e) {
78831       {
78832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78833       };
78834     } catch (...) {
78835       {
78836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78837       };
78838     }
78839   }
78840 }
78841
78842
78843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
78844   unsigned int jresult ;
78845   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78846   bool result;
78847
78848   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78849   {
78850     try {
78851       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
78852     } catch (std::out_of_range& e) {
78853       {
78854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78855       };
78856     } catch (std::exception& e) {
78857       {
78858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78859       };
78860     } catch (...) {
78861       {
78862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78863       };
78864     }
78865   }
78866   jresult = result;
78867   return jresult;
78868 }
78869
78870
78871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
78872   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78873   bool arg2 ;
78874
78875   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78876   arg2 = jarg2 ? true : false;
78877   {
78878     try {
78879       (arg1)->SetWrapMode(arg2);
78880     } catch (std::out_of_range& e) {
78881       {
78882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78883       };
78884     } catch (std::exception& e) {
78885       {
78886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78887       };
78888     } catch (...) {
78889       {
78890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78891       };
78892     }
78893   }
78894 }
78895
78896
78897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
78898   unsigned int jresult ;
78899   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78900   bool result;
78901
78902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78903   {
78904     try {
78905       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
78906     } catch (std::out_of_range& e) {
78907       {
78908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78909       };
78910     } catch (std::exception& e) {
78911       {
78912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78913       };
78914     } catch (...) {
78915       {
78916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78917       };
78918     }
78919   }
78920   jresult = result;
78921   return jresult;
78922 }
78923
78924
78925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
78926   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78927   Dali::Actor arg2 ;
78928   Dali::Actor *argp2 ;
78929
78930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78931   argp2 = (Dali::Actor *)jarg2;
78932   if (!argp2) {
78933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78934     return ;
78935   }
78936   arg2 = *argp2;
78937   {
78938     try {
78939       (arg1)->SetFocusIndicatorActor(arg2);
78940     } catch (std::out_of_range& e) {
78941       {
78942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78943       };
78944     } catch (std::exception& e) {
78945       {
78946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78947       };
78948     } catch (...) {
78949       {
78950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78951       };
78952     }
78953   }
78954 }
78955
78956
78957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
78958   void * jresult ;
78959   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78960   Dali::Actor result;
78961
78962   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78963   {
78964     try {
78965       result = (arg1)->GetFocusIndicatorActor();
78966     } catch (std::out_of_range& e) {
78967       {
78968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78969       };
78970     } catch (std::exception& e) {
78971       {
78972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78973       };
78974     } catch (...) {
78975       {
78976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78977       };
78978     }
78979   }
78980   jresult = new Dali::Actor((const Dali::Actor &)result);
78981   return jresult;
78982 }
78983
78984
78985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
78986   void * jresult ;
78987   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78988   Dali::Actor arg2 ;
78989   Dali::Actor *argp2 ;
78990   Dali::Actor result;
78991
78992   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78993   argp2 = (Dali::Actor *)jarg2;
78994   if (!argp2) {
78995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78996     return 0;
78997   }
78998   arg2 = *argp2;
78999   {
79000     try {
79001       result = (arg1)->GetFocusGroup(arg2);
79002     } catch (std::out_of_range& e) {
79003       {
79004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79005       };
79006     } catch (std::exception& e) {
79007       {
79008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79009       };
79010     } catch (...) {
79011       {
79012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79013       };
79014     }
79015   }
79016   jresult = new Dali::Actor((const Dali::Actor &)result);
79017   return jresult;
79018 }
79019
79020
79021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79022   void * jresult ;
79023   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79024   Dali::Vector2 result;
79025
79026   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79027   {
79028     try {
79029       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79030     } catch (std::out_of_range& e) {
79031       {
79032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79033       };
79034     } catch (std::exception& e) {
79035       {
79036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79037       };
79038     } catch (...) {
79039       {
79040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79041       };
79042     }
79043   }
79044   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79045   return jresult;
79046 }
79047
79048
79049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79050   void * jresult ;
79051   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79052   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79053
79054   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79055   {
79056     try {
79057       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79058     } catch (std::out_of_range& e) {
79059       {
79060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79061       };
79062     } catch (std::exception& e) {
79063       {
79064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79065       };
79066     } catch (...) {
79067       {
79068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79069       };
79070     }
79071   }
79072   jresult = (void *)result;
79073   return jresult;
79074 }
79075
79076
79077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79078   void * jresult ;
79079   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79080   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79081
79082   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79083   {
79084     try {
79085       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79086     } catch (std::out_of_range& e) {
79087       {
79088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79089       };
79090     } catch (std::exception& e) {
79091       {
79092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79093       };
79094     } catch (...) {
79095       {
79096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79097       };
79098     }
79099   }
79100   jresult = (void *)result;
79101   return jresult;
79102 }
79103
79104
79105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79106   void * jresult ;
79107   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79108   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79109
79110   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79111   {
79112     try {
79113       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79114     } catch (std::out_of_range& e) {
79115       {
79116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79117       };
79118     } catch (std::exception& e) {
79119       {
79120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79121       };
79122     } catch (...) {
79123       {
79124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79125       };
79126     }
79127   }
79128   jresult = (void *)result;
79129   return jresult;
79130 }
79131
79132
79133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79134   void * jresult ;
79135   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79136   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79137
79138   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79139   {
79140     try {
79141       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79142     } catch (std::out_of_range& e) {
79143       {
79144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79145       };
79146     } catch (std::exception& e) {
79147       {
79148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79149       };
79150     } catch (...) {
79151       {
79152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79153       };
79154     }
79155   }
79156   jresult = (void *)result;
79157   return jresult;
79158 }
79159
79160
79161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79162   void * jresult ;
79163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79164   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79165
79166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79167   {
79168     try {
79169       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79170     } catch (std::out_of_range& e) {
79171       {
79172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79173       };
79174     } catch (std::exception& e) {
79175       {
79176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79177       };
79178     } catch (...) {
79179       {
79180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79181       };
79182     }
79183   }
79184   jresult = (void *)result;
79185   return jresult;
79186 }
79187
79188
79189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79190   void * jresult ;
79191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79192   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79193
79194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79195   {
79196     try {
79197       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79198     } catch (std::out_of_range& e) {
79199       {
79200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79201       };
79202     } catch (std::exception& e) {
79203       {
79204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79205       };
79206     } catch (...) {
79207       {
79208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79209       };
79210     }
79211   }
79212   jresult = (void *)result;
79213   return jresult;
79214 }
79215
79216
79217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79218   void * jresult ;
79219   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79220   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79221
79222   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79223   {
79224     try {
79225       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79226     } catch (std::out_of_range& e) {
79227       {
79228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79229       };
79230     } catch (std::exception& e) {
79231       {
79232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79233       };
79234     } catch (...) {
79235       {
79236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79237       };
79238     }
79239   }
79240   jresult = (void *)result;
79241   return jresult;
79242 }
79243
79244
79245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79246   void * jresult ;
79247   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79248   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79249
79250   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79251   {
79252     try {
79253       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79254     } catch (std::out_of_range& e) {
79255       {
79256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79257       };
79258     } catch (std::exception& e) {
79259       {
79260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79261       };
79262     } catch (...) {
79263       {
79264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79265       };
79266     }
79267   }
79268   jresult = (void *)result;
79269   return jresult;
79270 }
79271
79272
79273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79274   void * jresult ;
79275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79276   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79277
79278   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79279   {
79280     try {
79281       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79282     } catch (std::out_of_range& e) {
79283       {
79284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79285       };
79286     } catch (std::exception& e) {
79287       {
79288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79289       };
79290     } catch (...) {
79291       {
79292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79293       };
79294     }
79295   }
79296   jresult = (void *)result;
79297   return jresult;
79298 }
79299
79300
79301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79302   void * jresult ;
79303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79304   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79305
79306   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79307   {
79308     try {
79309       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79310     } catch (std::out_of_range& e) {
79311       {
79312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79313       };
79314     } catch (std::exception& e) {
79315       {
79316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79317       };
79318     } catch (...) {
79319       {
79320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79321       };
79322     }
79323   }
79324   jresult = (void *)result;
79325   return jresult;
79326 }
79327
79328
79329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79330   void * jresult ;
79331   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79332   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79333
79334   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79335   {
79336     try {
79337       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79338     } catch (std::out_of_range& e) {
79339       {
79340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79341       };
79342     } catch (std::exception& e) {
79343       {
79344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79345       };
79346     } catch (...) {
79347       {
79348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79349       };
79350     }
79351   }
79352   jresult = (void *)result;
79353   return jresult;
79354 }
79355
79356
79357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79358   void * jresult ;
79359   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79360   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79361
79362   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79363   {
79364     try {
79365       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79366     } catch (std::out_of_range& e) {
79367       {
79368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79369       };
79370     } catch (std::exception& e) {
79371       {
79372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79373       };
79374     } catch (...) {
79375       {
79376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79377       };
79378     }
79379   }
79380   jresult = (void *)result;
79381   return jresult;
79382 }
79383
79384
79385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79386   void * jresult ;
79387   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79388   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79389
79390   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79391   {
79392     try {
79393       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79394     } catch (std::out_of_range& e) {
79395       {
79396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79397       };
79398     } catch (std::exception& e) {
79399       {
79400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79401       };
79402     } catch (...) {
79403       {
79404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79405       };
79406     }
79407   }
79408   jresult = (void *)result;
79409   return jresult;
79410 }
79411
79412
79413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
79414   void * jresult ;
79415   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79416   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79417
79418   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79419   {
79420     try {
79421       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
79422     } catch (std::out_of_range& e) {
79423       {
79424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79425       };
79426     } catch (std::exception& e) {
79427       {
79428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79429       };
79430     } catch (...) {
79431       {
79432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79433       };
79434     }
79435   }
79436   jresult = (void *)result;
79437   return jresult;
79438 }
79439
79440
79441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
79442   void * jresult ;
79443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79444   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79445
79446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79447   {
79448     try {
79449       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
79450     } catch (std::out_of_range& e) {
79451       {
79452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79453       };
79454     } catch (std::exception& e) {
79455       {
79456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79457       };
79458     } catch (...) {
79459       {
79460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79461       };
79462     }
79463   }
79464   jresult = (void *)result;
79465   return jresult;
79466 }
79467
79468
79469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
79470   void * jresult ;
79471   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79472   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79473
79474   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79475   {
79476     try {
79477       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
79478     } catch (std::out_of_range& e) {
79479       {
79480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79481       };
79482     } catch (std::exception& e) {
79483       {
79484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79485       };
79486     } catch (...) {
79487       {
79488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79489       };
79490     }
79491   }
79492   jresult = (void *)result;
79493   return jresult;
79494 }
79495
79496
79497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
79498   void * jresult ;
79499   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79500   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79501
79502   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79503   {
79504     try {
79505       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
79506     } catch (std::out_of_range& e) {
79507       {
79508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79509       };
79510     } catch (std::exception& e) {
79511       {
79512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79513       };
79514     } catch (...) {
79515       {
79516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79517       };
79518     }
79519   }
79520   jresult = (void *)result;
79521   return jresult;
79522 }
79523
79524
79525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
79526   void * jresult ;
79527   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79528   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79529
79530   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79531   {
79532     try {
79533       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
79534     } catch (std::out_of_range& e) {
79535       {
79536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79537       };
79538     } catch (std::exception& e) {
79539       {
79540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79541       };
79542     } catch (...) {
79543       {
79544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79545       };
79546     }
79547   }
79548   jresult = (void *)result;
79549   return jresult;
79550 }
79551
79552
79553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
79554   void * jresult ;
79555   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79556   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79557
79558   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79559   {
79560     try {
79561       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
79562     } catch (std::out_of_range& e) {
79563       {
79564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79565       };
79566     } catch (std::exception& e) {
79567       {
79568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79569       };
79570     } catch (...) {
79571       {
79572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79573       };
79574     }
79575   }
79576   jresult = (void *)result;
79577   return jresult;
79578 }
79579
79580
79581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
79582   void * jresult ;
79583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79584   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79585
79586   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79587   {
79588     try {
79589       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
79590     } catch (std::out_of_range& e) {
79591       {
79592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79593       };
79594     } catch (std::exception& e) {
79595       {
79596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79597       };
79598     } catch (...) {
79599       {
79600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79601       };
79602     }
79603   }
79604   jresult = (void *)result;
79605   return jresult;
79606 }
79607
79608
79609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
79610   void * jresult ;
79611   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79612   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79613
79614   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79615   {
79616     try {
79617       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
79618     } catch (std::out_of_range& e) {
79619       {
79620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79621       };
79622     } catch (std::exception& e) {
79623       {
79624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79625       };
79626     } catch (...) {
79627       {
79628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79629       };
79630     }
79631   }
79632   jresult = (void *)result;
79633   return jresult;
79634 }
79635
79636
79637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
79638   void * jresult ;
79639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79640   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79641
79642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79643   {
79644     try {
79645       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
79646     } catch (std::out_of_range& e) {
79647       {
79648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79649       };
79650     } catch (std::exception& e) {
79651       {
79652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79653       };
79654     } catch (...) {
79655       {
79656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79657       };
79658     }
79659   }
79660   jresult = (void *)result;
79661   return jresult;
79662 }
79663
79664
79665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
79666   void * jresult ;
79667   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79668   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79669
79670   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79671   {
79672     try {
79673       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
79674     } catch (std::out_of_range& e) {
79675       {
79676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79677       };
79678     } catch (std::exception& e) {
79679       {
79680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79681       };
79682     } catch (...) {
79683       {
79684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79685       };
79686     }
79687   }
79688   jresult = (void *)result;
79689   return jresult;
79690 }
79691
79692
79693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
79694   void * jresult ;
79695   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79696   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79697
79698   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79699   {
79700     try {
79701       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
79702     } catch (std::out_of_range& e) {
79703       {
79704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79705       };
79706     } catch (std::exception& e) {
79707       {
79708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79709       };
79710     } catch (...) {
79711       {
79712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79713       };
79714     }
79715   }
79716   jresult = (void *)result;
79717   return jresult;
79718 }
79719
79720
79721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
79722   void * jresult ;
79723   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79724   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79725
79726   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79727   {
79728     try {
79729       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
79730     } catch (std::out_of_range& e) {
79731       {
79732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79733       };
79734     } catch (std::exception& e) {
79735       {
79736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79737       };
79738     } catch (...) {
79739       {
79740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79741       };
79742     }
79743   }
79744   jresult = (void *)result;
79745   return jresult;
79746 }
79747
79748
79749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
79750   void * jresult ;
79751   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79752   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79753
79754   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79755   {
79756     try {
79757       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
79758     } catch (std::out_of_range& e) {
79759       {
79760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79761       };
79762     } catch (std::exception& e) {
79763       {
79764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79765       };
79766     } catch (...) {
79767       {
79768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79769       };
79770     }
79771   }
79772   jresult = (void *)result;
79773   return jresult;
79774 }
79775
79776
79777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
79778   void * jresult ;
79779   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79780   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79781
79782   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79783   {
79784     try {
79785       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
79786     } catch (std::out_of_range& e) {
79787       {
79788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79789       };
79790     } catch (std::exception& e) {
79791       {
79792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79793       };
79794     } catch (...) {
79795       {
79796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79797       };
79798     }
79799   }
79800   jresult = (void *)result;
79801   return jresult;
79802 }
79803
79804
79805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
79806   void * jresult ;
79807   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79808   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79809
79810   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79811   {
79812     try {
79813       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
79814     } catch (std::out_of_range& e) {
79815       {
79816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79817       };
79818     } catch (std::exception& e) {
79819       {
79820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79821       };
79822     } catch (...) {
79823       {
79824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79825       };
79826     }
79827   }
79828   jresult = (void *)result;
79829   return jresult;
79830 }
79831
79832
79833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
79834   void * jresult ;
79835   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79836   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79837
79838   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79839   {
79840     try {
79841       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
79842     } catch (std::out_of_range& e) {
79843       {
79844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79845       };
79846     } catch (std::exception& e) {
79847       {
79848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79849       };
79850     } catch (...) {
79851       {
79852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79853       };
79854     }
79855   }
79856   jresult = (void *)result;
79857   return jresult;
79858 }
79859
79860
79861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
79862   void * jresult ;
79863   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79864   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
79865
79866   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79867   {
79868     try {
79869       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
79870     } catch (std::out_of_range& e) {
79871       {
79872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79873       };
79874     } catch (std::exception& e) {
79875       {
79876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79877       };
79878     } catch (...) {
79879       {
79880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79881       };
79882     }
79883   }
79884   jresult = (void *)result;
79885   return jresult;
79886 }
79887
79888
79889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
79890   void * jresult ;
79891   Dali::Toolkit::StyleManager *result = 0 ;
79892
79893   {
79894     try {
79895       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
79896     } catch (std::out_of_range& e) {
79897       {
79898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79899       };
79900     } catch (std::exception& e) {
79901       {
79902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79903       };
79904     } catch (...) {
79905       {
79906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79907       };
79908     }
79909   }
79910   jresult = (void *)result;
79911   return jresult;
79912 }
79913
79914
79915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
79916   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
79917
79918   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
79919   {
79920     try {
79921       delete arg1;
79922     } catch (std::out_of_range& e) {
79923       {
79924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79925       };
79926     } catch (std::exception& e) {
79927       {
79928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79929       };
79930     } catch (...) {
79931       {
79932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79933       };
79934     }
79935   }
79936 }
79937
79938
79939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
79940   void * jresult ;
79941   Dali::Toolkit::StyleManager result;
79942
79943   {
79944     try {
79945       result = Dali::Toolkit::StyleManager::Get();
79946     } catch (std::out_of_range& e) {
79947       {
79948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79949       };
79950     } catch (std::exception& e) {
79951       {
79952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79953       };
79954     } catch (...) {
79955       {
79956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79957       };
79958     }
79959   }
79960   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
79961   return jresult;
79962 }
79963
79964
79965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
79966   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
79967   std::string *arg2 = 0 ;
79968
79969   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
79970   if (!jarg2) {
79971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79972     return ;
79973   }
79974   std::string arg2_str(jarg2);
79975   arg2 = &arg2_str;
79976   {
79977     try {
79978       (arg1)->ApplyTheme((std::string const &)*arg2);
79979     } catch (std::out_of_range& e) {
79980       {
79981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79982       };
79983     } catch (std::exception& e) {
79984       {
79985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79986       };
79987     } catch (...) {
79988       {
79989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79990       };
79991     }
79992   }
79993
79994   //argout typemap for const std::string&
79995
79996 }
79997
79998
79999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80000   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80001
80002   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80003   {
80004     try {
80005       (arg1)->ApplyDefaultTheme();
80006     } catch (std::out_of_range& e) {
80007       {
80008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80009       };
80010     } catch (std::exception& e) {
80011       {
80012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80013       };
80014     } catch (...) {
80015       {
80016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80017       };
80018     }
80019   }
80020 }
80021
80022
80023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80024   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80025   std::string *arg2 = 0 ;
80026   Dali::Property::Value *arg3 = 0 ;
80027
80028   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80029   if (!jarg2) {
80030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80031     return ;
80032   }
80033   std::string arg2_str(jarg2);
80034   arg2 = &arg2_str;
80035   arg3 = (Dali::Property::Value *)jarg3;
80036   if (!arg3) {
80037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80038     return ;
80039   }
80040   {
80041     try {
80042       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
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   //argout typemap for const std::string&
80059
80060 }
80061
80062
80063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80064   unsigned int jresult ;
80065   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80066   std::string *arg2 = 0 ;
80067   Dali::Property::Value *arg3 = 0 ;
80068   bool result;
80069
80070   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80071   if (!jarg2) {
80072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80073     return 0;
80074   }
80075   std::string arg2_str(jarg2);
80076   arg2 = &arg2_str;
80077   arg3 = (Dali::Property::Value *)jarg3;
80078   if (!arg3) {
80079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80080     return 0;
80081   }
80082   {
80083     try {
80084       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80085     } catch (std::out_of_range& e) {
80086       {
80087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80088       };
80089     } catch (std::exception& e) {
80090       {
80091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80092       };
80093     } catch (...) {
80094       {
80095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80096       };
80097     }
80098   }
80099   jresult = result;
80100
80101   //argout typemap for const std::string&
80102
80103   return jresult;
80104 }
80105
80106
80107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80108   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80109   Dali::Toolkit::Control arg2 ;
80110   std::string *arg3 = 0 ;
80111   std::string *arg4 = 0 ;
80112   Dali::Toolkit::Control *argp2 ;
80113
80114   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80115   argp2 = (Dali::Toolkit::Control *)jarg2;
80116   if (!argp2) {
80117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80118     return ;
80119   }
80120   arg2 = *argp2;
80121   if (!jarg3) {
80122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80123     return ;
80124   }
80125   std::string arg3_str(jarg3);
80126   arg3 = &arg3_str;
80127   if (!jarg4) {
80128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80129     return ;
80130   }
80131   std::string arg4_str(jarg4);
80132   arg4 = &arg4_str;
80133   {
80134     try {
80135       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80136     } catch (std::out_of_range& e) {
80137       {
80138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80139       };
80140     } catch (std::exception& e) {
80141       {
80142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80143       };
80144     } catch (...) {
80145       {
80146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80147       };
80148     }
80149   }
80150
80151   //argout typemap for const std::string&
80152
80153
80154   //argout typemap for const std::string&
80155
80156 }
80157
80158
80159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80160   void * jresult ;
80161   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80162   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80163
80164   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80165   {
80166     try {
80167       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80168     } catch (std::out_of_range& e) {
80169       {
80170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80171       };
80172     } catch (std::exception& e) {
80173       {
80174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80175       };
80176     } catch (...) {
80177       {
80178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80179       };
80180     }
80181   }
80182   jresult = (void *)result;
80183   return jresult;
80184 }
80185
80186
80187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80188   int jresult ;
80189   int result;
80190
80191   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80192   jresult = (int)result;
80193   return jresult;
80194 }
80195
80196
80197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80198   int jresult ;
80199   int result;
80200
80201   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80202   jresult = (int)result;
80203   return jresult;
80204 }
80205
80206
80207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80208   int jresult ;
80209   int result;
80210
80211   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80212   jresult = (int)result;
80213   return jresult;
80214 }
80215
80216
80217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80218   int jresult ;
80219   int result;
80220
80221   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80222   jresult = (int)result;
80223   return jresult;
80224 }
80225
80226
80227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80228   int jresult ;
80229   int result;
80230
80231   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80232   jresult = (int)result;
80233   return jresult;
80234 }
80235
80236
80237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80238   int jresult ;
80239   int result;
80240
80241   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80242   jresult = (int)result;
80243   return jresult;
80244 }
80245
80246
80247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80248   int jresult ;
80249   int result;
80250
80251   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80252   jresult = (int)result;
80253   return jresult;
80254 }
80255
80256
80257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80258   int jresult ;
80259   int result;
80260
80261   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80262   jresult = (int)result;
80263   return jresult;
80264 }
80265
80266
80267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80268   int jresult ;
80269   int result;
80270
80271   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80272   jresult = (int)result;
80273   return jresult;
80274 }
80275
80276
80277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80278   int jresult ;
80279   int result;
80280
80281   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80282   jresult = (int)result;
80283   return jresult;
80284 }
80285
80286
80287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80288   int jresult ;
80289   int result;
80290
80291   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80292   jresult = (int)result;
80293   return jresult;
80294 }
80295
80296
80297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80298   int jresult ;
80299   int result;
80300
80301   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80302   jresult = (int)result;
80303   return jresult;
80304 }
80305
80306
80307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80308   int jresult ;
80309   int result;
80310
80311   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80312   jresult = (int)result;
80313   return jresult;
80314 }
80315
80316
80317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80318   int jresult ;
80319   int result;
80320
80321   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80322   jresult = (int)result;
80323   return jresult;
80324 }
80325
80326
80327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80328   int jresult ;
80329   int result;
80330
80331   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80332   jresult = (int)result;
80333   return jresult;
80334 }
80335
80336
80337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80338   void * jresult ;
80339   Dali::Toolkit::Slider::Property *result = 0 ;
80340
80341   {
80342     try {
80343       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80344     } catch (std::out_of_range& e) {
80345       {
80346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80347       };
80348     } catch (std::exception& e) {
80349       {
80350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80351       };
80352     } catch (...) {
80353       {
80354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80355       };
80356     }
80357   }
80358   jresult = (void *)result;
80359   return jresult;
80360 }
80361
80362
80363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80364   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80365
80366   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80367   {
80368     try {
80369       delete arg1;
80370     } catch (std::out_of_range& e) {
80371       {
80372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80373       };
80374     } catch (std::exception& e) {
80375       {
80376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80377       };
80378     } catch (...) {
80379       {
80380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80381       };
80382     }
80383   }
80384 }
80385
80386
80387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80388   void * jresult ;
80389   Dali::Toolkit::Slider result;
80390
80391   {
80392     try {
80393       result = Dali::Toolkit::Slider::New();
80394     } catch (std::out_of_range& e) {
80395       {
80396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80397       };
80398     } catch (std::exception& e) {
80399       {
80400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80401       };
80402     } catch (...) {
80403       {
80404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80405       };
80406     }
80407   }
80408   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80409   return jresult;
80410 }
80411
80412
80413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
80414   void * jresult ;
80415   Dali::Toolkit::Slider *result = 0 ;
80416
80417   {
80418     try {
80419       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
80420     } catch (std::out_of_range& e) {
80421       {
80422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80423       };
80424     } catch (std::exception& e) {
80425       {
80426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80427       };
80428     } catch (...) {
80429       {
80430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80431       };
80432     }
80433   }
80434   jresult = (void *)result;
80435   return jresult;
80436 }
80437
80438
80439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
80440   void * jresult ;
80441   Dali::Toolkit::Slider *arg1 = 0 ;
80442   Dali::Toolkit::Slider *result = 0 ;
80443
80444   arg1 = (Dali::Toolkit::Slider *)jarg1;
80445   if (!arg1) {
80446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80447     return 0;
80448   }
80449   {
80450     try {
80451       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
80452     } catch (std::out_of_range& e) {
80453       {
80454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80455       };
80456     } catch (std::exception& e) {
80457       {
80458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80459       };
80460     } catch (...) {
80461       {
80462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80463       };
80464     }
80465   }
80466   jresult = (void *)result;
80467   return jresult;
80468 }
80469
80470
80471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
80472   void * jresult ;
80473   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80474   Dali::Toolkit::Slider *arg2 = 0 ;
80475   Dali::Toolkit::Slider *result = 0 ;
80476
80477   arg1 = (Dali::Toolkit::Slider *)jarg1;
80478   arg2 = (Dali::Toolkit::Slider *)jarg2;
80479   if (!arg2) {
80480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80481     return 0;
80482   }
80483   {
80484     try {
80485       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
80486     } catch (std::out_of_range& e) {
80487       {
80488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80489       };
80490     } catch (std::exception& e) {
80491       {
80492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80493       };
80494     } catch (...) {
80495       {
80496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80497       };
80498     }
80499   }
80500   jresult = (void *)result;
80501   return jresult;
80502 }
80503
80504
80505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
80506   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80507
80508   arg1 = (Dali::Toolkit::Slider *)jarg1;
80509   {
80510     try {
80511       delete arg1;
80512     } catch (std::out_of_range& e) {
80513       {
80514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80515       };
80516     } catch (std::exception& e) {
80517       {
80518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80519       };
80520     } catch (...) {
80521       {
80522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80523       };
80524     }
80525   }
80526 }
80527
80528
80529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
80530   void * jresult ;
80531   Dali::BaseHandle arg1 ;
80532   Dali::BaseHandle *argp1 ;
80533   Dali::Toolkit::Slider result;
80534
80535   argp1 = (Dali::BaseHandle *)jarg1;
80536   if (!argp1) {
80537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80538     return 0;
80539   }
80540   arg1 = *argp1;
80541   {
80542     try {
80543       result = Dali::Toolkit::Slider::DownCast(arg1);
80544     } catch (std::out_of_range& e) {
80545       {
80546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80547       };
80548     } catch (std::exception& e) {
80549       {
80550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80551       };
80552     } catch (...) {
80553       {
80554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80555       };
80556     }
80557   }
80558   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80559   return jresult;
80560 }
80561
80562
80563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
80564   void * jresult ;
80565   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80566   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80567
80568   arg1 = (Dali::Toolkit::Slider *)jarg1;
80569   {
80570     try {
80571       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
80572     } catch (std::out_of_range& e) {
80573       {
80574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80575       };
80576     } catch (std::exception& e) {
80577       {
80578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80579       };
80580     } catch (...) {
80581       {
80582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80583       };
80584     }
80585   }
80586   jresult = (void *)result;
80587   return jresult;
80588 }
80589
80590
80591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
80592   void * jresult ;
80593   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80594   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80595
80596   arg1 = (Dali::Toolkit::Slider *)jarg1;
80597   {
80598     try {
80599       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
80600     } catch (std::out_of_range& e) {
80601       {
80602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80603       };
80604     } catch (std::exception& e) {
80605       {
80606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80607       };
80608     } catch (...) {
80609       {
80610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80611       };
80612     }
80613   }
80614   jresult = (void *)result;
80615   return jresult;
80616 }
80617
80618
80619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
80620   void * jresult ;
80621   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80622   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
80623
80624   arg1 = (Dali::Toolkit::Slider *)jarg1;
80625   {
80626     try {
80627       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
80628     } catch (std::out_of_range& e) {
80629       {
80630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80631       };
80632     } catch (std::exception& e) {
80633       {
80634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80635       };
80636     } catch (...) {
80637       {
80638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80639       };
80640     }
80641   }
80642   jresult = (void *)result;
80643   return jresult;
80644 }
80645
80646
80647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
80648   int jresult ;
80649   int result;
80650
80651   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
80652   jresult = (int)result;
80653   return jresult;
80654 }
80655
80656
80657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
80658   int jresult ;
80659   int result;
80660
80661   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
80662   jresult = (int)result;
80663   return jresult;
80664 }
80665
80666
80667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
80668   int jresult ;
80669   int result;
80670
80671   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
80672   jresult = (int)result;
80673   return jresult;
80674 }
80675
80676
80677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
80678   int jresult ;
80679   int result;
80680
80681   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
80682   jresult = (int)result;
80683   return jresult;
80684 }
80685
80686
80687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
80688   void * jresult ;
80689   Dali::Toolkit::VideoView::Property *result = 0 ;
80690
80691   {
80692     try {
80693       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
80694     } catch (std::out_of_range& e) {
80695       {
80696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80697       };
80698     } catch (std::exception& e) {
80699       {
80700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80701       };
80702     } catch (...) {
80703       {
80704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80705       };
80706     }
80707   }
80708   jresult = (void *)result;
80709   return jresult;
80710 }
80711
80712
80713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
80714   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
80715
80716   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
80717   {
80718     try {
80719       delete arg1;
80720     } catch (std::out_of_range& e) {
80721       {
80722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80723       };
80724     } catch (std::exception& e) {
80725       {
80726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80727       };
80728     } catch (...) {
80729       {
80730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80731       };
80732     }
80733   }
80734 }
80735
80736
80737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
80738   void * jresult ;
80739   Dali::Toolkit::VideoView result;
80740
80741   {
80742     try {
80743       result = Dali::Toolkit::VideoView::New();
80744     } catch (std::out_of_range& e) {
80745       {
80746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80747       };
80748     } catch (std::exception& e) {
80749       {
80750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80751       };
80752     } catch (...) {
80753       {
80754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80755       };
80756     }
80757   }
80758   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
80759   return jresult;
80760 }
80761
80762
80763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
80764   void * jresult ;
80765   std::string *arg1 = 0 ;
80766   Dali::Toolkit::VideoView result;
80767
80768   if (!jarg1) {
80769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80770     return 0;
80771   }
80772   std::string arg1_str(jarg1);
80773   arg1 = &arg1_str;
80774   {
80775     try {
80776       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
80777     } catch (std::out_of_range& e) {
80778       {
80779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80780       };
80781     } catch (std::exception& e) {
80782       {
80783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80784       };
80785     } catch (...) {
80786       {
80787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80788       };
80789     }
80790   }
80791   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
80792
80793   //argout typemap for const std::string&
80794
80795   return jresult;
80796 }
80797
80798
80799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
80800   void * jresult ;
80801   Dali::Toolkit::VideoView *result = 0 ;
80802
80803   {
80804     try {
80805       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
80806     } catch (std::out_of_range& e) {
80807       {
80808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80809       };
80810     } catch (std::exception& e) {
80811       {
80812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80813       };
80814     } catch (...) {
80815       {
80816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80817       };
80818     }
80819   }
80820   jresult = (void *)result;
80821   return jresult;
80822 }
80823
80824
80825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
80826   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
80827
80828   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80829   {
80830     try {
80831       delete arg1;
80832     } catch (std::out_of_range& e) {
80833       {
80834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80835       };
80836     } catch (std::exception& e) {
80837       {
80838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80839       };
80840     } catch (...) {
80841       {
80842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80843       };
80844     }
80845   }
80846 }
80847
80848
80849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
80850   void * jresult ;
80851   Dali::Toolkit::VideoView *arg1 = 0 ;
80852   Dali::Toolkit::VideoView *result = 0 ;
80853
80854   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80855   if (!arg1) {
80856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
80857     return 0;
80858   }
80859   {
80860     try {
80861       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
80862     } catch (std::out_of_range& e) {
80863       {
80864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80865       };
80866     } catch (std::exception& e) {
80867       {
80868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80869       };
80870     } catch (...) {
80871       {
80872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80873       };
80874     }
80875   }
80876   jresult = (void *)result;
80877   return jresult;
80878 }
80879
80880
80881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
80882   void * jresult ;
80883   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
80884   Dali::Toolkit::VideoView *arg2 = 0 ;
80885   Dali::Toolkit::VideoView *result = 0 ;
80886
80887   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80888   arg2 = (Dali::Toolkit::VideoView *)jarg2;
80889   if (!arg2) {
80890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
80891     return 0;
80892   }
80893   {
80894     try {
80895       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
80896     } catch (std::out_of_range& e) {
80897       {
80898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80899       };
80900     } catch (std::exception& e) {
80901       {
80902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80903       };
80904     } catch (...) {
80905       {
80906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80907       };
80908     }
80909   }
80910   jresult = (void *)result;
80911   return jresult;
80912 }
80913
80914
80915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
80916   void * jresult ;
80917   Dali::BaseHandle arg1 ;
80918   Dali::BaseHandle *argp1 ;
80919   Dali::Toolkit::VideoView result;
80920
80921   argp1 = (Dali::BaseHandle *)jarg1;
80922   if (!argp1) {
80923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80924     return 0;
80925   }
80926   arg1 = *argp1;
80927   {
80928     try {
80929       result = Dali::Toolkit::VideoView::DownCast(arg1);
80930     } catch (std::out_of_range& e) {
80931       {
80932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80933       };
80934     } catch (std::exception& e) {
80935       {
80936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80937       };
80938     } catch (...) {
80939       {
80940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80941       };
80942     }
80943   }
80944   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
80945   return jresult;
80946 }
80947
80948
80949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
80950   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
80951
80952   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80953   {
80954     try {
80955       (arg1)->Play();
80956     } catch (std::out_of_range& e) {
80957       {
80958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80959       };
80960     } catch (std::exception& e) {
80961       {
80962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80963       };
80964     } catch (...) {
80965       {
80966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80967       };
80968     }
80969   }
80970 }
80971
80972
80973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
80974   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
80975
80976   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80977   {
80978     try {
80979       (arg1)->Pause();
80980     } catch (std::out_of_range& e) {
80981       {
80982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80983       };
80984     } catch (std::exception& e) {
80985       {
80986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80987       };
80988     } catch (...) {
80989       {
80990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80991       };
80992     }
80993   }
80994 }
80995
80996
80997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
80998   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
80999
81000   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81001   {
81002     try {
81003       (arg1)->Stop();
81004     } catch (std::out_of_range& e) {
81005       {
81006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81007       };
81008     } catch (std::exception& e) {
81009       {
81010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81011       };
81012     } catch (...) {
81013       {
81014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81015       };
81016     }
81017   }
81018 }
81019
81020
81021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81022   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81023   int arg2 ;
81024
81025   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81026   arg2 = (int)jarg2;
81027   {
81028     try {
81029       (arg1)->Forward(arg2);
81030     } catch (std::out_of_range& e) {
81031       {
81032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81033       };
81034     } catch (std::exception& e) {
81035       {
81036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81037       };
81038     } catch (...) {
81039       {
81040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81041       };
81042     }
81043   }
81044 }
81045
81046
81047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81048   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81049   int arg2 ;
81050
81051   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81052   arg2 = (int)jarg2;
81053   {
81054     try {
81055       (arg1)->Backward(arg2);
81056     } catch (std::out_of_range& e) {
81057       {
81058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81059       };
81060     } catch (std::exception& e) {
81061       {
81062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81063       };
81064     } catch (...) {
81065       {
81066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81067       };
81068     }
81069   }
81070 }
81071
81072
81073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81074   void * jresult ;
81075   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81076   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81077
81078   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81079   {
81080     try {
81081       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81082     } catch (std::out_of_range& e) {
81083       {
81084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81085       };
81086     } catch (std::exception& e) {
81087       {
81088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81089       };
81090     } catch (...) {
81091       {
81092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81093       };
81094     }
81095   }
81096   jresult = (void *)result;
81097   return jresult;
81098 }
81099
81100
81101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81102   int jresult ;
81103   int result;
81104
81105   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81106   jresult = (int)result;
81107   return jresult;
81108 }
81109
81110
81111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81112   int jresult ;
81113   int result;
81114
81115   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81116   jresult = (int)result;
81117   return jresult;
81118 }
81119
81120
81121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81122   int jresult ;
81123   int result;
81124
81125   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81126   jresult = (int)result;
81127   return jresult;
81128 }
81129
81130
81131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81132   int jresult ;
81133   int result;
81134
81135   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81136   jresult = (int)result;
81137   return jresult;
81138 }
81139
81140
81141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81142   int jresult ;
81143   int result;
81144
81145   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81146   jresult = (int)result;
81147   return jresult;
81148 }
81149
81150
81151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81152   int jresult ;
81153   int result;
81154
81155   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81156   jresult = (int)result;
81157   return jresult;
81158 }
81159
81160
81161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81162   int jresult ;
81163   int result;
81164
81165   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81166   jresult = (int)result;
81167   return jresult;
81168 }
81169
81170
81171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81172   int jresult ;
81173   int result;
81174
81175   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81176   jresult = (int)result;
81177   return jresult;
81178 }
81179
81180
81181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81182   int jresult ;
81183   int result;
81184
81185   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81186   jresult = (int)result;
81187   return jresult;
81188 }
81189
81190
81191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81192   int jresult ;
81193   int result;
81194
81195   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81196   jresult = (int)result;
81197   return jresult;
81198 }
81199
81200
81201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81202   int jresult ;
81203   int result;
81204
81205   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81206   jresult = (int)result;
81207   return jresult;
81208 }
81209
81210
81211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81212   int jresult ;
81213   int result;
81214
81215   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81216   jresult = (int)result;
81217   return jresult;
81218 }
81219
81220
81221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81222   int jresult ;
81223   int result;
81224
81225   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81226   jresult = (int)result;
81227   return jresult;
81228 }
81229
81230
81231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81232   int jresult ;
81233   int result;
81234
81235   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81236   jresult = (int)result;
81237   return jresult;
81238 }
81239
81240
81241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81242   int jresult ;
81243   int result;
81244
81245   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81246   jresult = (int)result;
81247   return jresult;
81248 }
81249
81250
81251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81252   int jresult ;
81253   int result;
81254
81255   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81256   jresult = (int)result;
81257   return jresult;
81258 }
81259
81260
81261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81262   int jresult ;
81263   int result;
81264
81265   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81266   jresult = (int)result;
81267   return jresult;
81268 }
81269
81270
81271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81272   int jresult ;
81273   int result;
81274
81275   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81276   jresult = (int)result;
81277   return jresult;
81278 }
81279
81280
81281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81282   int jresult ;
81283   int result;
81284
81285   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81286   jresult = (int)result;
81287   return jresult;
81288 }
81289
81290
81291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81292   int jresult ;
81293   int result;
81294
81295   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81296   jresult = (int)result;
81297   return jresult;
81298 }
81299
81300
81301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81302   int jresult ;
81303   int result;
81304
81305   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81306   jresult = (int)result;
81307   return jresult;
81308 }
81309
81310
81311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81312   void * jresult ;
81313   Dali::Toolkit::Popup::Property *result = 0 ;
81314
81315   {
81316     try {
81317       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81318     } catch (std::out_of_range& e) {
81319       {
81320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81321       };
81322     } catch (std::exception& e) {
81323       {
81324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81325       };
81326     } catch (...) {
81327       {
81328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81329       };
81330     }
81331   }
81332   jresult = (void *)result;
81333   return jresult;
81334 }
81335
81336
81337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81338   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81339
81340   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81341   {
81342     try {
81343       delete arg1;
81344     } catch (std::out_of_range& e) {
81345       {
81346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81347       };
81348     } catch (std::exception& e) {
81349       {
81350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81351       };
81352     } catch (...) {
81353       {
81354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81355       };
81356     }
81357   }
81358 }
81359
81360
81361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81362   void * jresult ;
81363   Dali::Toolkit::Popup *result = 0 ;
81364
81365   {
81366     try {
81367       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81368     } catch (std::out_of_range& e) {
81369       {
81370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81371       };
81372     } catch (std::exception& e) {
81373       {
81374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81375       };
81376     } catch (...) {
81377       {
81378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81379       };
81380     }
81381   }
81382   jresult = (void *)result;
81383   return jresult;
81384 }
81385
81386
81387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81388   void * jresult ;
81389   Dali::Toolkit::Popup result;
81390
81391   {
81392     try {
81393       result = Dali::Toolkit::Popup::New();
81394     } catch (std::out_of_range& e) {
81395       {
81396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81397       };
81398     } catch (std::exception& e) {
81399       {
81400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81401       };
81402     } catch (...) {
81403       {
81404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81405       };
81406     }
81407   }
81408   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81409   return jresult;
81410 }
81411
81412
81413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
81414   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81415
81416   arg1 = (Dali::Toolkit::Popup *)jarg1;
81417   {
81418     try {
81419       delete arg1;
81420     } catch (std::out_of_range& e) {
81421       {
81422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81423       };
81424     } catch (std::exception& e) {
81425       {
81426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81427       };
81428     } catch (...) {
81429       {
81430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81431       };
81432     }
81433   }
81434 }
81435
81436
81437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
81438   void * jresult ;
81439   Dali::Toolkit::Popup *arg1 = 0 ;
81440   Dali::Toolkit::Popup *result = 0 ;
81441
81442   arg1 = (Dali::Toolkit::Popup *)jarg1;
81443   if (!arg1) {
81444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81445     return 0;
81446   }
81447   {
81448     try {
81449       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
81450     } catch (std::out_of_range& e) {
81451       {
81452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81453       };
81454     } catch (std::exception& e) {
81455       {
81456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81457       };
81458     } catch (...) {
81459       {
81460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81461       };
81462     }
81463   }
81464   jresult = (void *)result;
81465   return jresult;
81466 }
81467
81468
81469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
81470   void * jresult ;
81471   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81472   Dali::Toolkit::Popup *arg2 = 0 ;
81473   Dali::Toolkit::Popup *result = 0 ;
81474
81475   arg1 = (Dali::Toolkit::Popup *)jarg1;
81476   arg2 = (Dali::Toolkit::Popup *)jarg2;
81477   if (!arg2) {
81478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81479     return 0;
81480   }
81481   {
81482     try {
81483       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
81484     } catch (std::out_of_range& e) {
81485       {
81486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81487       };
81488     } catch (std::exception& e) {
81489       {
81490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81491       };
81492     } catch (...) {
81493       {
81494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81495       };
81496     }
81497   }
81498   jresult = (void *)result;
81499   return jresult;
81500 }
81501
81502
81503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
81504   void * jresult ;
81505   Dali::BaseHandle arg1 ;
81506   Dali::BaseHandle *argp1 ;
81507   Dali::Toolkit::Popup result;
81508
81509   argp1 = (Dali::BaseHandle *)jarg1;
81510   if (!argp1) {
81511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81512     return 0;
81513   }
81514   arg1 = *argp1;
81515   {
81516     try {
81517       result = Dali::Toolkit::Popup::DownCast(arg1);
81518     } catch (std::out_of_range& e) {
81519       {
81520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81521       };
81522     } catch (std::exception& e) {
81523       {
81524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81525       };
81526     } catch (...) {
81527       {
81528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81529       };
81530     }
81531   }
81532   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81533   return jresult;
81534 }
81535
81536
81537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
81538   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81539   Dali::Actor arg2 ;
81540   Dali::Actor *argp2 ;
81541
81542   arg1 = (Dali::Toolkit::Popup *)jarg1;
81543   argp2 = (Dali::Actor *)jarg2;
81544   if (!argp2) {
81545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81546     return ;
81547   }
81548   arg2 = *argp2;
81549   {
81550     try {
81551       (arg1)->SetTitle(arg2);
81552     } catch (std::out_of_range& e) {
81553       {
81554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81555       };
81556     } catch (std::exception& e) {
81557       {
81558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81559       };
81560     } catch (...) {
81561       {
81562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81563       };
81564     }
81565   }
81566 }
81567
81568
81569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
81570   void * jresult ;
81571   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81572   Dali::Actor result;
81573
81574   arg1 = (Dali::Toolkit::Popup *)jarg1;
81575   {
81576     try {
81577       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
81578     } catch (std::out_of_range& e) {
81579       {
81580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81581       };
81582     } catch (std::exception& e) {
81583       {
81584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81585       };
81586     } catch (...) {
81587       {
81588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81589       };
81590     }
81591   }
81592   jresult = new Dali::Actor((const Dali::Actor &)result);
81593   return jresult;
81594 }
81595
81596
81597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
81598   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81599   Dali::Actor arg2 ;
81600   Dali::Actor *argp2 ;
81601
81602   arg1 = (Dali::Toolkit::Popup *)jarg1;
81603   argp2 = (Dali::Actor *)jarg2;
81604   if (!argp2) {
81605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81606     return ;
81607   }
81608   arg2 = *argp2;
81609   {
81610     try {
81611       (arg1)->SetContent(arg2);
81612     } catch (std::out_of_range& e) {
81613       {
81614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81615       };
81616     } catch (std::exception& e) {
81617       {
81618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81619       };
81620     } catch (...) {
81621       {
81622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81623       };
81624     }
81625   }
81626 }
81627
81628
81629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
81630   void * jresult ;
81631   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81632   Dali::Actor result;
81633
81634   arg1 = (Dali::Toolkit::Popup *)jarg1;
81635   {
81636     try {
81637       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
81638     } catch (std::out_of_range& e) {
81639       {
81640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81641       };
81642     } catch (std::exception& e) {
81643       {
81644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81645       };
81646     } catch (...) {
81647       {
81648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81649       };
81650     }
81651   }
81652   jresult = new Dali::Actor((const Dali::Actor &)result);
81653   return jresult;
81654 }
81655
81656
81657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
81658   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81659   Dali::Actor arg2 ;
81660   Dali::Actor *argp2 ;
81661
81662   arg1 = (Dali::Toolkit::Popup *)jarg1;
81663   argp2 = (Dali::Actor *)jarg2;
81664   if (!argp2) {
81665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81666     return ;
81667   }
81668   arg2 = *argp2;
81669   {
81670     try {
81671       (arg1)->SetFooter(arg2);
81672     } catch (std::out_of_range& e) {
81673       {
81674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81675       };
81676     } catch (std::exception& e) {
81677       {
81678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81679       };
81680     } catch (...) {
81681       {
81682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81683       };
81684     }
81685   }
81686 }
81687
81688
81689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
81690   void * jresult ;
81691   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81692   Dali::Actor result;
81693
81694   arg1 = (Dali::Toolkit::Popup *)jarg1;
81695   {
81696     try {
81697       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
81698     } catch (std::out_of_range& e) {
81699       {
81700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81701       };
81702     } catch (std::exception& e) {
81703       {
81704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81705       };
81706     } catch (...) {
81707       {
81708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81709       };
81710     }
81711   }
81712   jresult = new Dali::Actor((const Dali::Actor &)result);
81713   return jresult;
81714 }
81715
81716
81717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
81718   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81719   Dali::Toolkit::Popup::DisplayState arg2 ;
81720
81721   arg1 = (Dali::Toolkit::Popup *)jarg1;
81722   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
81723   {
81724     try {
81725       (arg1)->SetDisplayState(arg2);
81726     } catch (std::out_of_range& e) {
81727       {
81728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81729       };
81730     } catch (std::exception& e) {
81731       {
81732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81733       };
81734     } catch (...) {
81735       {
81736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81737       };
81738     }
81739   }
81740 }
81741
81742
81743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
81744   int jresult ;
81745   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81746   Dali::Toolkit::Popup::DisplayState result;
81747
81748   arg1 = (Dali::Toolkit::Popup *)jarg1;
81749   {
81750     try {
81751       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
81752     } catch (std::out_of_range& e) {
81753       {
81754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81755       };
81756     } catch (std::exception& e) {
81757       {
81758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81759       };
81760     } catch (...) {
81761       {
81762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81763       };
81764     }
81765   }
81766   jresult = (int)result;
81767   return jresult;
81768 }
81769
81770
81771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
81772   void * jresult ;
81773   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81774   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
81775
81776   arg1 = (Dali::Toolkit::Popup *)jarg1;
81777   {
81778     try {
81779       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
81780     } catch (std::out_of_range& e) {
81781       {
81782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81783       };
81784     } catch (std::exception& e) {
81785       {
81786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81787       };
81788     } catch (...) {
81789       {
81790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81791       };
81792     }
81793   }
81794   jresult = (void *)result;
81795   return jresult;
81796 }
81797
81798
81799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
81800   void * jresult ;
81801   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81802   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
81803
81804   arg1 = (Dali::Toolkit::Popup *)jarg1;
81805   {
81806     try {
81807       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
81808     } catch (std::out_of_range& e) {
81809       {
81810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81811       };
81812     } catch (std::exception& e) {
81813       {
81814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81815       };
81816     } catch (...) {
81817       {
81818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81819       };
81820     }
81821   }
81822   jresult = (void *)result;
81823   return jresult;
81824 }
81825
81826
81827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
81828   void * jresult ;
81829   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81830   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
81831
81832   arg1 = (Dali::Toolkit::Popup *)jarg1;
81833   {
81834     try {
81835       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
81836     } catch (std::out_of_range& e) {
81837       {
81838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81839       };
81840     } catch (std::exception& e) {
81841       {
81842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81843       };
81844     } catch (...) {
81845       {
81846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81847       };
81848     }
81849   }
81850   jresult = (void *)result;
81851   return jresult;
81852 }
81853
81854
81855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
81856   void * jresult ;
81857   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81858   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
81859
81860   arg1 = (Dali::Toolkit::Popup *)jarg1;
81861   {
81862     try {
81863       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
81864     } catch (std::out_of_range& e) {
81865       {
81866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81867       };
81868     } catch (std::exception& e) {
81869       {
81870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81871       };
81872     } catch (...) {
81873       {
81874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81875       };
81876     }
81877   }
81878   jresult = (void *)result;
81879   return jresult;
81880 }
81881
81882
81883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
81884   void * jresult ;
81885   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81886   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
81887
81888   arg1 = (Dali::Toolkit::Popup *)jarg1;
81889   {
81890     try {
81891       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
81892     } catch (std::out_of_range& e) {
81893       {
81894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81895       };
81896     } catch (std::exception& e) {
81897       {
81898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81899       };
81900     } catch (...) {
81901       {
81902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81903       };
81904     }
81905   }
81906   jresult = (void *)result;
81907   return jresult;
81908 }
81909
81910
81911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
81912   int jresult ;
81913   int result;
81914
81915   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
81916   jresult = (int)result;
81917   return jresult;
81918 }
81919
81920
81921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
81922   int jresult ;
81923   int result;
81924
81925   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
81926   jresult = (int)result;
81927   return jresult;
81928 }
81929
81930
81931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
81932   int jresult ;
81933   int result;
81934
81935   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
81936   jresult = (int)result;
81937   return jresult;
81938 }
81939
81940
81941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
81942   int jresult ;
81943   int result;
81944
81945   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
81946   jresult = (int)result;
81947   return jresult;
81948 }
81949
81950
81951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
81952   int jresult ;
81953   int result;
81954
81955   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
81956   jresult = (int)result;
81957   return jresult;
81958 }
81959
81960
81961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
81962   int jresult ;
81963   int result;
81964
81965   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
81966   jresult = (int)result;
81967   return jresult;
81968 }
81969
81970
81971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
81972   int jresult ;
81973   int result;
81974
81975   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
81976   jresult = (int)result;
81977   return jresult;
81978 }
81979
81980
81981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
81982   int jresult ;
81983   int result;
81984
81985   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
81986   jresult = (int)result;
81987   return jresult;
81988 }
81989
81990
81991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
81992   int jresult ;
81993   int result;
81994
81995   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
81996   jresult = (int)result;
81997   return jresult;
81998 }
81999
82000
82001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82002   void * jresult ;
82003   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82004
82005   {
82006     try {
82007       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82008     } catch (std::out_of_range& e) {
82009       {
82010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82011       };
82012     } catch (std::exception& e) {
82013       {
82014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82015       };
82016     } catch (...) {
82017       {
82018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82019       };
82020     }
82021   }
82022   jresult = (void *)result;
82023   return jresult;
82024 }
82025
82026
82027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82028   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82029
82030   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82031   {
82032     try {
82033       delete arg1;
82034     } catch (std::out_of_range& e) {
82035       {
82036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82037       };
82038     } catch (std::exception& e) {
82039       {
82040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82041       };
82042     } catch (...) {
82043       {
82044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82045       };
82046     }
82047   }
82048 }
82049
82050
82051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82052   void * jresult ;
82053   Dali::Toolkit::ProgressBar result;
82054
82055   {
82056     try {
82057       result = Dali::Toolkit::ProgressBar::New();
82058     } catch (std::out_of_range& e) {
82059       {
82060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82061       };
82062     } catch (std::exception& e) {
82063       {
82064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82065       };
82066     } catch (...) {
82067       {
82068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82069       };
82070     }
82071   }
82072   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82073   return jresult;
82074 }
82075
82076
82077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82078   void * jresult ;
82079   Dali::Toolkit::ProgressBar *result = 0 ;
82080
82081   {
82082     try {
82083       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82084     } catch (std::out_of_range& e) {
82085       {
82086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82087       };
82088     } catch (std::exception& e) {
82089       {
82090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82091       };
82092     } catch (...) {
82093       {
82094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82095       };
82096     }
82097   }
82098   jresult = (void *)result;
82099   return jresult;
82100 }
82101
82102
82103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82104   void * jresult ;
82105   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82106   Dali::Toolkit::ProgressBar *result = 0 ;
82107
82108   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82109   if (!arg1) {
82110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82111     return 0;
82112   }
82113   {
82114     try {
82115       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82116     } catch (std::out_of_range& e) {
82117       {
82118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82119       };
82120     } catch (std::exception& e) {
82121       {
82122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82123       };
82124     } catch (...) {
82125       {
82126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82127       };
82128     }
82129   }
82130   jresult = (void *)result;
82131   return jresult;
82132 }
82133
82134
82135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82136   void * jresult ;
82137   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82138   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82139   Dali::Toolkit::ProgressBar *result = 0 ;
82140
82141   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82142   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82143   if (!arg2) {
82144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82145     return 0;
82146   }
82147   {
82148     try {
82149       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82150     } catch (std::out_of_range& e) {
82151       {
82152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82153       };
82154     } catch (std::exception& e) {
82155       {
82156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82157       };
82158     } catch (...) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82161       };
82162     }
82163   }
82164   jresult = (void *)result;
82165   return jresult;
82166 }
82167
82168
82169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82170   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82171
82172   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82173   {
82174     try {
82175       delete arg1;
82176     } catch (std::out_of_range& e) {
82177       {
82178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82179       };
82180     } catch (std::exception& e) {
82181       {
82182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82183       };
82184     } catch (...) {
82185       {
82186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82187       };
82188     }
82189   }
82190 }
82191
82192
82193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82194   void * jresult ;
82195   Dali::BaseHandle arg1 ;
82196   Dali::BaseHandle *argp1 ;
82197   Dali::Toolkit::ProgressBar result;
82198
82199   argp1 = (Dali::BaseHandle *)jarg1;
82200   if (!argp1) {
82201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82202     return 0;
82203   }
82204   arg1 = *argp1;
82205   {
82206     try {
82207       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82208     } catch (std::out_of_range& e) {
82209       {
82210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82211       };
82212     } catch (std::exception& e) {
82213       {
82214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82215       };
82216     } catch (...) {
82217       {
82218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82219       };
82220     }
82221   }
82222   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82223   return jresult;
82224 }
82225
82226
82227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82228   void * jresult ;
82229   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82230   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82231
82232   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82233   {
82234     try {
82235       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82236     } catch (std::out_of_range& e) {
82237       {
82238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82239       };
82240     } catch (std::exception& e) {
82241       {
82242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82243       };
82244     } catch (...) {
82245       {
82246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82247       };
82248     }
82249   }
82250   jresult = (void *)result;
82251   return jresult;
82252 }
82253
82254
82255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82256   void * jresult ;
82257   Dali::Toolkit::GaussianBlurView *result = 0 ;
82258
82259   {
82260     try {
82261       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82262     } catch (std::out_of_range& e) {
82263       {
82264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82265       };
82266     } catch (std::exception& e) {
82267       {
82268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82269       };
82270     } catch (...) {
82271       {
82272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82273       };
82274     }
82275   }
82276   jresult = (void *)result;
82277   return jresult;
82278 }
82279
82280
82281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82282   void * jresult ;
82283   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82284   Dali::Toolkit::GaussianBlurView *result = 0 ;
82285
82286   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82287   if (!arg1) {
82288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82289     return 0;
82290   }
82291   {
82292     try {
82293       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82294     } catch (std::out_of_range& e) {
82295       {
82296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82297       };
82298     } catch (std::exception& e) {
82299       {
82300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82301       };
82302     } catch (...) {
82303       {
82304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82305       };
82306     }
82307   }
82308   jresult = (void *)result;
82309   return jresult;
82310 }
82311
82312
82313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82314   void * jresult ;
82315   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82316   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82317   Dali::Toolkit::GaussianBlurView *result = 0 ;
82318
82319   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82320   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82321   if (!arg2) {
82322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82323     return 0;
82324   }
82325   {
82326     try {
82327       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82328     } catch (std::out_of_range& e) {
82329       {
82330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82331       };
82332     } catch (std::exception& e) {
82333       {
82334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82335       };
82336     } catch (...) {
82337       {
82338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82339       };
82340     }
82341   }
82342   jresult = (void *)result;
82343   return jresult;
82344 }
82345
82346
82347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82348   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82349
82350   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82351   {
82352     try {
82353       delete arg1;
82354     } catch (std::out_of_range& e) {
82355       {
82356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82357       };
82358     } catch (std::exception& e) {
82359       {
82360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82361       };
82362     } catch (...) {
82363       {
82364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82365       };
82366     }
82367   }
82368 }
82369
82370
82371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
82372   void * jresult ;
82373   Dali::BaseHandle arg1 ;
82374   Dali::BaseHandle *argp1 ;
82375   Dali::Toolkit::GaussianBlurView result;
82376
82377   argp1 = (Dali::BaseHandle *)jarg1;
82378   if (!argp1) {
82379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82380     return 0;
82381   }
82382   arg1 = *argp1;
82383   {
82384     try {
82385       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82386     } catch (std::out_of_range& e) {
82387       {
82388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82389       };
82390     } catch (std::exception& e) {
82391       {
82392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82393       };
82394     } catch (...) {
82395       {
82396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82397       };
82398     }
82399   }
82400   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82401   return jresult;
82402 }
82403
82404
82405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
82406   void * jresult ;
82407   Dali::Toolkit::GaussianBlurView result;
82408
82409   {
82410     try {
82411       result = Dali::Toolkit::GaussianBlurView::New();
82412     } catch (std::out_of_range& e) {
82413       {
82414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82415       };
82416     } catch (std::exception& e) {
82417       {
82418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82419       };
82420     } catch (...) {
82421       {
82422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82423       };
82424     }
82425   }
82426   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82427   return jresult;
82428 }
82429
82430
82431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
82432   void * jresult ;
82433   unsigned int arg1 ;
82434   float arg2 ;
82435   Dali::Pixel::Format arg3 ;
82436   float arg4 ;
82437   float arg5 ;
82438   bool arg6 ;
82439   Dali::Toolkit::GaussianBlurView result;
82440
82441   arg1 = (unsigned int)jarg1;
82442   arg2 = (float)jarg2;
82443   arg3 = (Dali::Pixel::Format)jarg3;
82444   arg4 = (float)jarg4;
82445   arg5 = (float)jarg5;
82446   arg6 = jarg6 ? true : false;
82447   {
82448     try {
82449       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
82450     } catch (std::out_of_range& e) {
82451       {
82452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82453       };
82454     } catch (std::exception& e) {
82455       {
82456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82457       };
82458     } catch (...) {
82459       {
82460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82461       };
82462     }
82463   }
82464   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82465   return jresult;
82466 }
82467
82468
82469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
82470   void * jresult ;
82471   unsigned int arg1 ;
82472   float arg2 ;
82473   Dali::Pixel::Format arg3 ;
82474   float arg4 ;
82475   float arg5 ;
82476   Dali::Toolkit::GaussianBlurView result;
82477
82478   arg1 = (unsigned int)jarg1;
82479   arg2 = (float)jarg2;
82480   arg3 = (Dali::Pixel::Format)jarg3;
82481   arg4 = (float)jarg4;
82482   arg5 = (float)jarg5;
82483   {
82484     try {
82485       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
82486     } catch (std::out_of_range& e) {
82487       {
82488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82489       };
82490     } catch (std::exception& e) {
82491       {
82492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82493       };
82494     } catch (...) {
82495       {
82496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82497       };
82498     }
82499   }
82500   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82501   return jresult;
82502 }
82503
82504
82505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
82506   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82507   Dali::Actor arg2 ;
82508   Dali::Actor *argp2 ;
82509
82510   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82511   argp2 = (Dali::Actor *)jarg2;
82512   if (!argp2) {
82513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82514     return ;
82515   }
82516   arg2 = *argp2;
82517   {
82518     try {
82519       (arg1)->Add(arg2);
82520     } catch (std::out_of_range& e) {
82521       {
82522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82523       };
82524     } catch (std::exception& e) {
82525       {
82526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82527       };
82528     } catch (...) {
82529       {
82530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82531       };
82532     }
82533   }
82534 }
82535
82536
82537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
82538   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82539   Dali::Actor arg2 ;
82540   Dali::Actor *argp2 ;
82541
82542   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82543   argp2 = (Dali::Actor *)jarg2;
82544   if (!argp2) {
82545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82546     return ;
82547   }
82548   arg2 = *argp2;
82549   {
82550     try {
82551       (arg1)->Remove(arg2);
82552     } catch (std::out_of_range& e) {
82553       {
82554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82555       };
82556     } catch (std::exception& e) {
82557       {
82558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82559       };
82560     } catch (...) {
82561       {
82562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82563       };
82564     }
82565   }
82566 }
82567
82568
82569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
82570   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82571
82572   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82573   {
82574     try {
82575       (arg1)->Activate();
82576     } catch (std::out_of_range& e) {
82577       {
82578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82579       };
82580     } catch (std::exception& e) {
82581       {
82582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82583       };
82584     } catch (...) {
82585       {
82586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82587       };
82588     }
82589   }
82590 }
82591
82592
82593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
82594   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82595
82596   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82597   {
82598     try {
82599       (arg1)->ActivateOnce();
82600     } catch (std::out_of_range& e) {
82601       {
82602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82603       };
82604     } catch (std::exception& e) {
82605       {
82606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82607       };
82608     } catch (...) {
82609       {
82610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82611       };
82612     }
82613   }
82614 }
82615
82616
82617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
82618   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82619
82620   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82621   {
82622     try {
82623       (arg1)->Deactivate();
82624     } catch (std::out_of_range& e) {
82625       {
82626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82627       };
82628     } catch (std::exception& e) {
82629       {
82630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82631       };
82632     } catch (...) {
82633       {
82634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82635       };
82636     }
82637   }
82638 }
82639
82640
82641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
82642   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82643   Dali::Image arg2 ;
82644   Dali::FrameBufferImage arg3 ;
82645   Dali::Image *argp2 ;
82646   Dali::FrameBufferImage *argp3 ;
82647
82648   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82649   argp2 = (Dali::Image *)jarg2;
82650   if (!argp2) {
82651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
82652     return ;
82653   }
82654   arg2 = *argp2;
82655   argp3 = (Dali::FrameBufferImage *)jarg3;
82656   if (!argp3) {
82657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
82658     return ;
82659   }
82660   arg3 = *argp3;
82661   {
82662     try {
82663       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
82664     } catch (std::out_of_range& e) {
82665       {
82666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82667       };
82668     } catch (std::exception& e) {
82669       {
82670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82671       };
82672     } catch (...) {
82673       {
82674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82675       };
82676     }
82677   }
82678 }
82679
82680
82681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
82682   int jresult ;
82683   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82684   Dali::Property::Index result;
82685
82686   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82687   {
82688     try {
82689       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
82690     } catch (std::out_of_range& e) {
82691       {
82692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82693       };
82694     } catch (std::exception& e) {
82695       {
82696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82697       };
82698     } catch (...) {
82699       {
82700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82701       };
82702     }
82703   }
82704   jresult = result;
82705   return jresult;
82706 }
82707
82708
82709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
82710   void * jresult ;
82711   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82712   Dali::FrameBufferImage result;
82713
82714   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82715   {
82716     try {
82717       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
82718     } catch (std::out_of_range& e) {
82719       {
82720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82721       };
82722     } catch (std::exception& e) {
82723       {
82724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82725       };
82726     } catch (...) {
82727       {
82728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82729       };
82730     }
82731   }
82732   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
82733   return jresult;
82734 }
82735
82736
82737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
82738   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82739   Dali::Vector4 *arg2 = 0 ;
82740
82741   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82742   arg2 = (Dali::Vector4 *)jarg2;
82743   if (!arg2) {
82744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
82745     return ;
82746   }
82747   {
82748     try {
82749       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
82750     } catch (std::out_of_range& e) {
82751       {
82752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82753       };
82754     } catch (std::exception& e) {
82755       {
82756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82757       };
82758     } catch (...) {
82759       {
82760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82761       };
82762     }
82763   }
82764 }
82765
82766
82767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
82768   void * jresult ;
82769   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82770   Dali::Vector4 result;
82771
82772   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82773   {
82774     try {
82775       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
82776     } catch (std::out_of_range& e) {
82777       {
82778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82779       };
82780     } catch (std::exception& e) {
82781       {
82782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82783       };
82784     } catch (...) {
82785       {
82786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82787       };
82788     }
82789   }
82790   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
82791   return jresult;
82792 }
82793
82794
82795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
82796   void * jresult ;
82797   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82798   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
82799
82800   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82801   {
82802     try {
82803       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
82804     } catch (std::out_of_range& e) {
82805       {
82806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82807       };
82808     } catch (std::exception& e) {
82809       {
82810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82811       };
82812     } catch (...) {
82813       {
82814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82815       };
82816     }
82817   }
82818   jresult = (void *)result;
82819   return jresult;
82820 }
82821
82822
82823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
82824   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
82825
82826   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
82827   {
82828     try {
82829       delete arg1;
82830     } catch (std::out_of_range& e) {
82831       {
82832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82833       };
82834     } catch (std::exception& e) {
82835       {
82836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82837       };
82838     } catch (...) {
82839       {
82840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82841       };
82842     }
82843   }
82844 }
82845
82846
82847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
82848   unsigned int jresult ;
82849   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
82850   unsigned int result;
82851
82852   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
82853   {
82854     try {
82855       result = (unsigned int)(arg1)->GetNumberOfPages();
82856     } catch (std::out_of_range& e) {
82857       {
82858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82859       };
82860     } catch (std::exception& e) {
82861       {
82862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82863       };
82864     } catch (...) {
82865       {
82866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82867       };
82868     }
82869   }
82870   jresult = result;
82871   return jresult;
82872 }
82873
82874
82875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
82876   void * jresult ;
82877   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
82878   unsigned int arg2 ;
82879   Dali::Texture result;
82880
82881   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
82882   arg2 = (unsigned int)jarg2;
82883   {
82884     try {
82885       result = (arg1)->NewPage(arg2);
82886     } catch (std::out_of_range& e) {
82887       {
82888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82889       };
82890     } catch (std::exception& e) {
82891       {
82892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82893       };
82894     } catch (...) {
82895       {
82896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82897       };
82898     }
82899   }
82900   jresult = new Dali::Texture((const Dali::Texture &)result);
82901   return jresult;
82902 }
82903
82904
82905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
82906   int jresult ;
82907   int result;
82908
82909   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
82910   jresult = (int)result;
82911   return jresult;
82912 }
82913
82914
82915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
82916   int jresult ;
82917   int result;
82918
82919   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
82920   jresult = (int)result;
82921   return jresult;
82922 }
82923
82924
82925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
82926   int jresult ;
82927   int result;
82928
82929   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
82930   jresult = (int)result;
82931   return jresult;
82932 }
82933
82934
82935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
82936   void * jresult ;
82937   Dali::Toolkit::PageTurnView::Property *result = 0 ;
82938
82939   {
82940     try {
82941       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
82942     } catch (std::out_of_range& e) {
82943       {
82944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82945       };
82946     } catch (std::exception& e) {
82947       {
82948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82949       };
82950     } catch (...) {
82951       {
82952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82953       };
82954     }
82955   }
82956   jresult = (void *)result;
82957   return jresult;
82958 }
82959
82960
82961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
82962   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
82963
82964   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
82965   {
82966     try {
82967       delete arg1;
82968     } catch (std::out_of_range& e) {
82969       {
82970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82971       };
82972     } catch (std::exception& e) {
82973       {
82974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82975       };
82976     } catch (...) {
82977       {
82978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82979       };
82980     }
82981   }
82982 }
82983
82984
82985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
82986   void * jresult ;
82987   Dali::Toolkit::PageTurnView *result = 0 ;
82988
82989   {
82990     try {
82991       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
82992     } catch (std::out_of_range& e) {
82993       {
82994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82995       };
82996     } catch (std::exception& e) {
82997       {
82998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82999       };
83000     } catch (...) {
83001       {
83002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83003       };
83004     }
83005   }
83006   jresult = (void *)result;
83007   return jresult;
83008 }
83009
83010
83011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83012   void * jresult ;
83013   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83014   Dali::Toolkit::PageTurnView *result = 0 ;
83015
83016   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83017   if (!arg1) {
83018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83019     return 0;
83020   }
83021   {
83022     try {
83023       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83024     } catch (std::out_of_range& e) {
83025       {
83026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83027       };
83028     } catch (std::exception& e) {
83029       {
83030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83031       };
83032     } catch (...) {
83033       {
83034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83035       };
83036     }
83037   }
83038   jresult = (void *)result;
83039   return jresult;
83040 }
83041
83042
83043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83044   void * jresult ;
83045   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83046   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83047   Dali::Toolkit::PageTurnView *result = 0 ;
83048
83049   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83050   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83051   if (!arg2) {
83052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83053     return 0;
83054   }
83055   {
83056     try {
83057       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83058     } catch (std::out_of_range& e) {
83059       {
83060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83061       };
83062     } catch (std::exception& e) {
83063       {
83064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83065       };
83066     } catch (...) {
83067       {
83068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83069       };
83070     }
83071   }
83072   jresult = (void *)result;
83073   return jresult;
83074 }
83075
83076
83077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83078   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83079
83080   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83081   {
83082     try {
83083       delete arg1;
83084     } catch (std::out_of_range& e) {
83085       {
83086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83087       };
83088     } catch (std::exception& e) {
83089       {
83090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83091       };
83092     } catch (...) {
83093       {
83094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83095       };
83096     }
83097   }
83098 }
83099
83100
83101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83102   void * jresult ;
83103   Dali::BaseHandle arg1 ;
83104   Dali::BaseHandle *argp1 ;
83105   Dali::Toolkit::PageTurnView result;
83106
83107   argp1 = (Dali::BaseHandle *)jarg1;
83108   if (!argp1) {
83109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83110     return 0;
83111   }
83112   arg1 = *argp1;
83113   {
83114     try {
83115       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83116     } catch (std::out_of_range& e) {
83117       {
83118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83119       };
83120     } catch (std::exception& e) {
83121       {
83122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83123       };
83124     } catch (...) {
83125       {
83126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83127       };
83128     }
83129   }
83130   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83131   return jresult;
83132 }
83133
83134
83135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83136   void * jresult ;
83137   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83138   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83139
83140   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83141   {
83142     try {
83143       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83144     } catch (std::out_of_range& e) {
83145       {
83146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83147       };
83148     } catch (std::exception& e) {
83149       {
83150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83151       };
83152     } catch (...) {
83153       {
83154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83155       };
83156     }
83157   }
83158   jresult = (void *)result;
83159   return jresult;
83160 }
83161
83162
83163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83164   void * jresult ;
83165   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83166   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83167
83168   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83169   {
83170     try {
83171       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83172     } catch (std::out_of_range& e) {
83173       {
83174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83175       };
83176     } catch (std::exception& e) {
83177       {
83178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83179       };
83180     } catch (...) {
83181       {
83182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83183       };
83184     }
83185   }
83186   jresult = (void *)result;
83187   return jresult;
83188 }
83189
83190
83191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83192   void * jresult ;
83193   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83194   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83195
83196   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83197   {
83198     try {
83199       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83200     } catch (std::out_of_range& e) {
83201       {
83202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83203       };
83204     } catch (std::exception& e) {
83205       {
83206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83207       };
83208     } catch (...) {
83209       {
83210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83211       };
83212     }
83213   }
83214   jresult = (void *)result;
83215   return jresult;
83216 }
83217
83218
83219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83220   void * jresult ;
83221   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83222   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83223
83224   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83225   {
83226     try {
83227       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83228     } catch (std::out_of_range& e) {
83229       {
83230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83231       };
83232     } catch (std::exception& e) {
83233       {
83234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83235       };
83236     } catch (...) {
83237       {
83238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83239       };
83240     }
83241   }
83242   jresult = (void *)result;
83243   return jresult;
83244 }
83245
83246
83247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
83248   void * jresult ;
83249   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83250
83251   {
83252     try {
83253       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83254     } catch (std::out_of_range& e) {
83255       {
83256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83257       };
83258     } catch (std::exception& e) {
83259       {
83260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83261       };
83262     } catch (...) {
83263       {
83264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83265       };
83266     }
83267   }
83268   jresult = (void *)result;
83269   return jresult;
83270 }
83271
83272
83273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83274   void * jresult ;
83275   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83276   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83277
83278   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83279   if (!arg1) {
83280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83281     return 0;
83282   }
83283   {
83284     try {
83285       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83286     } catch (std::out_of_range& e) {
83287       {
83288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83289       };
83290     } catch (std::exception& e) {
83291       {
83292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83293       };
83294     } catch (...) {
83295       {
83296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83297       };
83298     }
83299   }
83300   jresult = (void *)result;
83301   return jresult;
83302 }
83303
83304
83305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83306   void * jresult ;
83307   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83308   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83309   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83310
83311   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83312   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83313   if (!arg2) {
83314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83315     return 0;
83316   }
83317   {
83318     try {
83319       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83320     } catch (std::out_of_range& e) {
83321       {
83322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83323       };
83324     } catch (std::exception& e) {
83325       {
83326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83327       };
83328     } catch (...) {
83329       {
83330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83331       };
83332     }
83333   }
83334   jresult = (void *)result;
83335   return jresult;
83336 }
83337
83338
83339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83340   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83341
83342   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83343   {
83344     try {
83345       delete arg1;
83346     } catch (std::out_of_range& e) {
83347       {
83348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83349       };
83350     } catch (std::exception& e) {
83351       {
83352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83353       };
83354     } catch (...) {
83355       {
83356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83357       };
83358     }
83359   }
83360 }
83361
83362
83363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83364   void * jresult ;
83365   Dali::Toolkit::PageFactory *arg1 = 0 ;
83366   Dali::Vector2 *arg2 = 0 ;
83367   Dali::Toolkit::PageTurnLandscapeView result;
83368
83369   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83370   if (!arg1) {
83371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83372     return 0;
83373   }
83374   arg2 = (Dali::Vector2 *)jarg2;
83375   if (!arg2) {
83376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83377     return 0;
83378   }
83379   {
83380     try {
83381       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83382     } catch (std::out_of_range& e) {
83383       {
83384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83385       };
83386     } catch (std::exception& e) {
83387       {
83388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83389       };
83390     } catch (...) {
83391       {
83392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83393       };
83394     }
83395   }
83396   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83397   return jresult;
83398 }
83399
83400
83401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83402   void * jresult ;
83403   Dali::BaseHandle arg1 ;
83404   Dali::BaseHandle *argp1 ;
83405   Dali::Toolkit::PageTurnLandscapeView result;
83406
83407   argp1 = (Dali::BaseHandle *)jarg1;
83408   if (!argp1) {
83409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83410     return 0;
83411   }
83412   arg1 = *argp1;
83413   {
83414     try {
83415       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
83416     } catch (std::out_of_range& e) {
83417       {
83418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83419       };
83420     } catch (std::exception& e) {
83421       {
83422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83423       };
83424     } catch (...) {
83425       {
83426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83427       };
83428     }
83429   }
83430   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83431   return jresult;
83432 }
83433
83434
83435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
83436   void * jresult ;
83437   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83438
83439   {
83440     try {
83441       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
83442     } catch (std::out_of_range& e) {
83443       {
83444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83445       };
83446     } catch (std::exception& e) {
83447       {
83448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83449       };
83450     } catch (...) {
83451       {
83452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83453       };
83454     }
83455   }
83456   jresult = (void *)result;
83457   return jresult;
83458 }
83459
83460
83461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
83462   void * jresult ;
83463   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
83464   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83465
83466   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83467   if (!arg1) {
83468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83469     return 0;
83470   }
83471   {
83472     try {
83473       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
83474     } catch (std::out_of_range& e) {
83475       {
83476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83477       };
83478     } catch (std::exception& e) {
83479       {
83480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83481       };
83482     } catch (...) {
83483       {
83484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83485       };
83486     }
83487   }
83488   jresult = (void *)result;
83489   return jresult;
83490 }
83491
83492
83493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
83494   void * jresult ;
83495   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83496   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
83497   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83498
83499   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83500   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
83501   if (!arg2) {
83502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83503     return 0;
83504   }
83505   {
83506     try {
83507       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
83508     } catch (std::out_of_range& e) {
83509       {
83510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83511       };
83512     } catch (std::exception& e) {
83513       {
83514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83515       };
83516     } catch (...) {
83517       {
83518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83519       };
83520     }
83521   }
83522   jresult = (void *)result;
83523   return jresult;
83524 }
83525
83526
83527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
83528   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83529
83530   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83531   {
83532     try {
83533       delete arg1;
83534     } catch (std::out_of_range& e) {
83535       {
83536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83537       };
83538     } catch (std::exception& e) {
83539       {
83540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83541       };
83542     } catch (...) {
83543       {
83544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83545       };
83546     }
83547   }
83548 }
83549
83550
83551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
83552   void * jresult ;
83553   Dali::Toolkit::PageFactory *arg1 = 0 ;
83554   Dali::Vector2 *arg2 = 0 ;
83555   Dali::Toolkit::PageTurnPortraitView result;
83556
83557   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83558   if (!arg1) {
83559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83560     return 0;
83561   }
83562   arg2 = (Dali::Vector2 *)jarg2;
83563   if (!arg2) {
83564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83565     return 0;
83566   }
83567   {
83568     try {
83569       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
83570     } catch (std::out_of_range& e) {
83571       {
83572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83573       };
83574     } catch (std::exception& e) {
83575       {
83576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83577       };
83578     } catch (...) {
83579       {
83580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83581       };
83582     }
83583   }
83584   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83585   return jresult;
83586 }
83587
83588
83589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
83590   void * jresult ;
83591   Dali::BaseHandle arg1 ;
83592   Dali::BaseHandle *argp1 ;
83593   Dali::Toolkit::PageTurnPortraitView result;
83594
83595   argp1 = (Dali::BaseHandle *)jarg1;
83596   if (!argp1) {
83597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83598     return 0;
83599   }
83600   arg1 = *argp1;
83601   {
83602     try {
83603       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
83604     } catch (std::out_of_range& e) {
83605       {
83606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83607       };
83608     } catch (std::exception& e) {
83609       {
83610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83611       };
83612     } catch (...) {
83613       {
83614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83615       };
83616     }
83617   }
83618   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83619   return jresult;
83620 }
83621
83622
83623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
83624   int jresult ;
83625   int result;
83626
83627   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
83628   jresult = (int)result;
83629   return jresult;
83630 }
83631
83632
83633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
83634   int jresult ;
83635   int result;
83636
83637   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
83638   jresult = (int)result;
83639   return jresult;
83640 }
83641
83642
83643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
83644   int jresult ;
83645   int result;
83646
83647   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
83648   jresult = (int)result;
83649   return jresult;
83650 }
83651
83652
83653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
83654   void * jresult ;
83655   Dali::Toolkit::ToggleButton::Property *result = 0 ;
83656
83657   {
83658     try {
83659       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
83660     } catch (std::out_of_range& e) {
83661       {
83662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83663       };
83664     } catch (std::exception& e) {
83665       {
83666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83667       };
83668     } catch (...) {
83669       {
83670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83671       };
83672     }
83673   }
83674   jresult = (void *)result;
83675   return jresult;
83676 }
83677
83678
83679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
83680   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
83681
83682   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
83683   {
83684     try {
83685       delete arg1;
83686     } catch (std::out_of_range& e) {
83687       {
83688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83689       };
83690     } catch (std::exception& e) {
83691       {
83692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83693       };
83694     } catch (...) {
83695       {
83696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83697       };
83698     }
83699   }
83700 }
83701
83702
83703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
83704   void * jresult ;
83705   Dali::Toolkit::ToggleButton *result = 0 ;
83706
83707   {
83708     try {
83709       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
83710     } catch (std::out_of_range& e) {
83711       {
83712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83713       };
83714     } catch (std::exception& e) {
83715       {
83716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83717       };
83718     } catch (...) {
83719       {
83720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83721       };
83722     }
83723   }
83724   jresult = (void *)result;
83725   return jresult;
83726 }
83727
83728
83729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
83730   void * jresult ;
83731   Dali::Toolkit::ToggleButton *arg1 = 0 ;
83732   Dali::Toolkit::ToggleButton *result = 0 ;
83733
83734   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
83735   if (!arg1) {
83736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
83737     return 0;
83738   }
83739   {
83740     try {
83741       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
83742     } catch (std::out_of_range& e) {
83743       {
83744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83745       };
83746     } catch (std::exception& e) {
83747       {
83748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83749       };
83750     } catch (...) {
83751       {
83752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83753       };
83754     }
83755   }
83756   jresult = (void *)result;
83757   return jresult;
83758 }
83759
83760
83761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
83762   void * jresult ;
83763   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
83764   Dali::Toolkit::ToggleButton *arg2 = 0 ;
83765   Dali::Toolkit::ToggleButton *result = 0 ;
83766
83767   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
83768   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
83769   if (!arg2) {
83770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
83771     return 0;
83772   }
83773   {
83774     try {
83775       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
83776     } catch (std::out_of_range& e) {
83777       {
83778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83779       };
83780     } catch (std::exception& e) {
83781       {
83782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83783       };
83784     } catch (...) {
83785       {
83786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83787       };
83788     }
83789   }
83790   jresult = (void *)result;
83791   return jresult;
83792 }
83793
83794
83795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
83796   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
83797
83798   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
83799   {
83800     try {
83801       delete arg1;
83802     } catch (std::out_of_range& e) {
83803       {
83804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83805       };
83806     } catch (std::exception& e) {
83807       {
83808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83809       };
83810     } catch (...) {
83811       {
83812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83813       };
83814     }
83815   }
83816 }
83817
83818
83819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
83820   void * jresult ;
83821   Dali::Toolkit::ToggleButton result;
83822
83823   {
83824     try {
83825       result = Dali::Toolkit::ToggleButton::New();
83826     } catch (std::out_of_range& e) {
83827       {
83828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83829       };
83830     } catch (std::exception& e) {
83831       {
83832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83833       };
83834     } catch (...) {
83835       {
83836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83837       };
83838     }
83839   }
83840   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
83841   return jresult;
83842 }
83843
83844
83845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
83846   void * jresult ;
83847   Dali::BaseHandle arg1 ;
83848   Dali::BaseHandle *argp1 ;
83849   Dali::Toolkit::ToggleButton result;
83850
83851   argp1 = (Dali::BaseHandle *)jarg1;
83852   if (!argp1) {
83853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83854     return 0;
83855   }
83856   arg1 = *argp1;
83857   {
83858     try {
83859       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
83860     } catch (std::out_of_range& e) {
83861       {
83862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83863       };
83864     } catch (std::exception& e) {
83865       {
83866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83867       };
83868     } catch (...) {
83869       {
83870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83871       };
83872     }
83873   }
83874   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
83875   return jresult;
83876 }
83877
83878
83879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
83880   void * jresult ;
83881   Dali::Toolkit::Visual::Base *result = 0 ;
83882
83883   {
83884     try {
83885       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
83886     } catch (std::out_of_range& e) {
83887       {
83888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83889       };
83890     } catch (std::exception& e) {
83891       {
83892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83893       };
83894     } catch (...) {
83895       {
83896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83897       };
83898     }
83899   }
83900   jresult = (void *)result;
83901   return jresult;
83902 }
83903
83904
83905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
83906   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
83907
83908   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
83909   {
83910     try {
83911       delete arg1;
83912     } catch (std::out_of_range& e) {
83913       {
83914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83915       };
83916     } catch (std::exception& e) {
83917       {
83918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83919       };
83920     } catch (...) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83923       };
83924     }
83925   }
83926 }
83927
83928
83929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
83930   void * jresult ;
83931   Dali::Toolkit::Visual::Base *arg1 = 0 ;
83932   Dali::Toolkit::Visual::Base *result = 0 ;
83933
83934   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
83935   if (!arg1) {
83936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
83937     return 0;
83938   }
83939   {
83940     try {
83941       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
83942     } catch (std::out_of_range& e) {
83943       {
83944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83945       };
83946     } catch (std::exception& e) {
83947       {
83948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83949       };
83950     } catch (...) {
83951       {
83952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83953       };
83954     }
83955   }
83956   jresult = (void *)result;
83957   return jresult;
83958 }
83959
83960
83961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
83962   void * jresult ;
83963   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
83964   Dali::Toolkit::Visual::Base *arg2 = 0 ;
83965   Dali::Toolkit::Visual::Base *result = 0 ;
83966
83967   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
83968   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
83969   if (!arg2) {
83970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
83971     return 0;
83972   }
83973   {
83974     try {
83975       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
83976     } catch (std::out_of_range& e) {
83977       {
83978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83979       };
83980     } catch (std::exception& e) {
83981       {
83982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83983       };
83984     } catch (...) {
83985       {
83986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83987       };
83988     }
83989   }
83990   jresult = (void *)result;
83991   return jresult;
83992 }
83993
83994
83995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
83996   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
83997   std::string *arg2 = 0 ;
83998
83999   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84000   if (!jarg2) {
84001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84002     return ;
84003   }
84004   std::string arg2_str(jarg2);
84005   arg2 = &arg2_str;
84006   {
84007     try {
84008       (arg1)->SetName((std::string const &)*arg2);
84009     } catch (std::out_of_range& e) {
84010       {
84011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84012       };
84013     } catch (std::exception& e) {
84014       {
84015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84016       };
84017     } catch (...) {
84018       {
84019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84020       };
84021     }
84022   }
84023
84024   //argout typemap for const std::string&
84025
84026 }
84027
84028
84029 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84030   char * jresult ;
84031   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84032   std::string *result = 0 ;
84033
84034   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84035   {
84036     try {
84037       result = (std::string *) &(arg1)->GetName();
84038     } catch (std::out_of_range& e) {
84039       {
84040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84041       };
84042     } catch (std::exception& e) {
84043       {
84044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84045       };
84046     } catch (...) {
84047       {
84048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84049       };
84050     }
84051   }
84052   jresult = SWIG_csharp_string_callback(result->c_str());
84053   return jresult;
84054 }
84055
84056
84057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84058   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84059   Dali::Property::Map *arg2 = 0 ;
84060   Dali::Size arg3 ;
84061   Dali::Size *argp3 ;
84062
84063   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84064   arg2 = (Dali::Property::Map *)jarg2;
84065   if (!arg2) {
84066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84067     return ;
84068   }
84069   argp3 = (Dali::Size *)jarg3;
84070   if (!argp3) {
84071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84072     return ;
84073   }
84074   arg3 = *argp3;
84075   {
84076     try {
84077       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84078     } catch (std::out_of_range& e) {
84079       {
84080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84081       };
84082     } catch (std::exception& e) {
84083       {
84084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84085       };
84086     } catch (...) {
84087       {
84088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84089       };
84090     }
84091   }
84092 }
84093
84094
84095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84096   float jresult ;
84097   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84098   float arg2 ;
84099   float result;
84100
84101   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84102   arg2 = (float)jarg2;
84103   {
84104     try {
84105       result = (float)(arg1)->GetHeightForWidth(arg2);
84106     } catch (std::out_of_range& e) {
84107       {
84108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84109       };
84110     } catch (std::exception& e) {
84111       {
84112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84113       };
84114     } catch (...) {
84115       {
84116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84117       };
84118     }
84119   }
84120   jresult = result;
84121   return jresult;
84122 }
84123
84124
84125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84126   float jresult ;
84127   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84128   float arg2 ;
84129   float result;
84130
84131   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84132   arg2 = (float)jarg2;
84133   {
84134     try {
84135       result = (float)(arg1)->GetWidthForHeight(arg2);
84136     } catch (std::out_of_range& e) {
84137       {
84138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84139       };
84140     } catch (std::exception& e) {
84141       {
84142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84143       };
84144     } catch (...) {
84145       {
84146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84147       };
84148     }
84149   }
84150   jresult = result;
84151   return jresult;
84152 }
84153
84154
84155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84156   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84157   Dali::Vector2 *arg2 = 0 ;
84158
84159   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84160   arg2 = (Dali::Vector2 *)jarg2;
84161   if (!arg2) {
84162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84163     return ;
84164   }
84165   {
84166     try {
84167       (arg1)->GetNaturalSize(*arg2);
84168     } catch (std::out_of_range& e) {
84169       {
84170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84171       };
84172     } catch (std::exception& e) {
84173       {
84174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84175       };
84176     } catch (...) {
84177       {
84178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84179       };
84180     }
84181   }
84182 }
84183
84184
84185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84186   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84187   float arg2 ;
84188
84189   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84190   arg2 = (float)jarg2;
84191   {
84192     try {
84193       (arg1)->SetDepthIndex(arg2);
84194     } catch (std::out_of_range& e) {
84195       {
84196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84197       };
84198     } catch (std::exception& e) {
84199       {
84200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84201       };
84202     } catch (...) {
84203       {
84204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84205       };
84206     }
84207   }
84208 }
84209
84210
84211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84212   float jresult ;
84213   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84214   float result;
84215
84216   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84217   {
84218     try {
84219       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84220     } catch (std::out_of_range& e) {
84221       {
84222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84223       };
84224     } catch (std::exception& e) {
84225       {
84226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84227       };
84228     } catch (...) {
84229       {
84230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84231       };
84232     }
84233   }
84234   jresult = result;
84235   return jresult;
84236 }
84237
84238
84239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84240   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84241   Dali::Property::Map *arg2 = 0 ;
84242
84243   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84244   arg2 = (Dali::Property::Map *)jarg2;
84245   if (!arg2) {
84246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84247     return ;
84248   }
84249   {
84250     try {
84251       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84252     } catch (std::out_of_range& e) {
84253       {
84254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84255       };
84256     } catch (std::exception& e) {
84257       {
84258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84259       };
84260     } catch (...) {
84261       {
84262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84263       };
84264     }
84265   }
84266 }
84267
84268
84269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84270   void * jresult ;
84271   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84272   Dali::Toolkit::Visual::Base *result = 0 ;
84273
84274   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84275   {
84276     try {
84277       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84278     } catch (std::out_of_range& e) {
84279       {
84280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84281       };
84282     } catch (std::exception& e) {
84283       {
84284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84285       };
84286     } catch (...) {
84287       {
84288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84289       };
84290     }
84291   }
84292   jresult = (void *)result;
84293   return jresult;
84294 }
84295
84296
84297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84298   void * jresult ;
84299   Dali::Toolkit::VisualFactory result;
84300
84301   {
84302     try {
84303       result = Dali::Toolkit::VisualFactory::Get();
84304     } catch (std::out_of_range& e) {
84305       {
84306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84307       };
84308     } catch (std::exception& e) {
84309       {
84310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84311       };
84312     } catch (...) {
84313       {
84314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84315       };
84316     }
84317   }
84318   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84319   return jresult;
84320 }
84321
84322
84323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84324   void * jresult ;
84325   Dali::Toolkit::VisualFactory *result = 0 ;
84326
84327   {
84328     try {
84329       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84330     } catch (std::out_of_range& e) {
84331       {
84332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84333       };
84334     } catch (std::exception& e) {
84335       {
84336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84337       };
84338     } catch (...) {
84339       {
84340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84341       };
84342     }
84343   }
84344   jresult = (void *)result;
84345   return jresult;
84346 }
84347
84348
84349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84350   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84351
84352   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84353   {
84354     try {
84355       delete arg1;
84356     } catch (std::out_of_range& e) {
84357       {
84358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84359       };
84360     } catch (std::exception& e) {
84361       {
84362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84363       };
84364     } catch (...) {
84365       {
84366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84367       };
84368     }
84369   }
84370 }
84371
84372
84373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84374   void * jresult ;
84375   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84376   Dali::Toolkit::VisualFactory *result = 0 ;
84377
84378   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84379   if (!arg1) {
84380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84381     return 0;
84382   }
84383   {
84384     try {
84385       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84386     } catch (std::out_of_range& e) {
84387       {
84388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (std::exception& e) {
84391       {
84392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84393       };
84394     } catch (...) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84397       };
84398     }
84399   }
84400   jresult = (void *)result;
84401   return jresult;
84402 }
84403
84404
84405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
84406   void * jresult ;
84407   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84408   Dali::Toolkit::VisualFactory *arg2 = 0 ;
84409   Dali::Toolkit::VisualFactory *result = 0 ;
84410
84411   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84412   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
84413   if (!arg2) {
84414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84415     return 0;
84416   }
84417   {
84418     try {
84419       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
84420     } catch (std::out_of_range& e) {
84421       {
84422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84423       };
84424     } catch (std::exception& e) {
84425       {
84426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84427       };
84428     } catch (...) {
84429       {
84430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84431       };
84432     }
84433   }
84434   jresult = (void *)result;
84435   return jresult;
84436 }
84437
84438
84439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
84440   void * jresult ;
84441   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84442   Dali::Property::Map *arg2 = 0 ;
84443   Dali::Toolkit::Visual::Base result;
84444
84445   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84446   arg2 = (Dali::Property::Map *)jarg2;
84447   if (!arg2) {
84448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84449     return 0;
84450   }
84451   {
84452     try {
84453       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
84454     } catch (std::out_of_range& e) {
84455       {
84456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84457       };
84458     } catch (std::exception& e) {
84459       {
84460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84461       };
84462     } catch (...) {
84463       {
84464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84465       };
84466     }
84467   }
84468   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84469   return jresult;
84470 }
84471
84472
84473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
84474   void * jresult ;
84475   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84476   Dali::Image *arg2 = 0 ;
84477   Dali::Toolkit::Visual::Base result;
84478
84479   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84480   arg2 = (Dali::Image *)jarg2;
84481   if (!arg2) {
84482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
84483     return 0;
84484   }
84485   {
84486     try {
84487       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
84488     } catch (std::out_of_range& e) {
84489       {
84490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84491       };
84492     } catch (std::exception& e) {
84493       {
84494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84495       };
84496     } catch (...) {
84497       {
84498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84499       };
84500     }
84501   }
84502   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84503   return jresult;
84504 }
84505
84506
84507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
84508   void * jresult ;
84509   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84510   std::string *arg2 = 0 ;
84511   Dali::ImageDimensions arg3 ;
84512   Dali::ImageDimensions *argp3 ;
84513   Dali::Toolkit::Visual::Base result;
84514
84515   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84516   if (!jarg2) {
84517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84518     return 0;
84519   }
84520   std::string arg2_str(jarg2);
84521   arg2 = &arg2_str;
84522   argp3 = (Dali::ImageDimensions *)jarg3;
84523   if (!argp3) {
84524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84525     return 0;
84526   }
84527   arg3 = *argp3;
84528   {
84529     try {
84530       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
84531     } catch (std::out_of_range& e) {
84532       {
84533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84534       };
84535     } catch (std::exception& e) {
84536       {
84537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84538       };
84539     } catch (...) {
84540       {
84541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84542       };
84543     }
84544   }
84545   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84546
84547   //argout typemap for const std::string&
84548
84549   return jresult;
84550 }
84551
84552
84553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
84554   void * jresult ;
84555   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84556
84557   {
84558     try {
84559       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
84560     } catch (std::out_of_range& e) {
84561       {
84562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84563       };
84564     } catch (std::exception& e) {
84565       {
84566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84567       };
84568     } catch (...) {
84569       {
84570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84571       };
84572     }
84573   }
84574   jresult = (void *)result;
84575   return jresult;
84576 }
84577
84578
84579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
84580   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84581
84582   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84583   {
84584     try {
84585       delete arg1;
84586     } catch (std::out_of_range& e) {
84587       {
84588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84589       };
84590     } catch (std::exception& e) {
84591       {
84592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84593       };
84594     } catch (...) {
84595       {
84596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84597       };
84598     }
84599   }
84600 }
84601
84602
84603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
84604   void * jresult ;
84605   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
84606   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84607
84608   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84609   if (!arg1) {
84610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
84611     return 0;
84612   }
84613   {
84614     try {
84615       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
84616     } catch (std::out_of_range& e) {
84617       {
84618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84619       };
84620     } catch (std::exception& e) {
84621       {
84622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84623       };
84624     } catch (...) {
84625       {
84626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84627       };
84628     }
84629   }
84630   jresult = (void *)result;
84631   return jresult;
84632 }
84633
84634
84635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
84636   void * jresult ;
84637   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84638   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
84639   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84640
84641   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84642   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
84643   if (!arg2) {
84644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
84645     return 0;
84646   }
84647   {
84648     try {
84649       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
84650     } catch (std::out_of_range& e) {
84651       {
84652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84653       };
84654     } catch (std::exception& e) {
84655       {
84656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84657       };
84658     } catch (...) {
84659       {
84660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84661       };
84662     }
84663   }
84664   jresult = (void *)result;
84665   return jresult;
84666 }
84667
84668
84669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
84670   void * jresult ;
84671   Dali::Toolkit::AsyncImageLoader result;
84672
84673   {
84674     try {
84675       result = Dali::Toolkit::AsyncImageLoader::New();
84676     } catch (std::out_of_range& e) {
84677       {
84678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84679       };
84680     } catch (std::exception& e) {
84681       {
84682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84683       };
84684     } catch (...) {
84685       {
84686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84687       };
84688     }
84689   }
84690   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
84691   return jresult;
84692 }
84693
84694
84695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
84696   void * jresult ;
84697   Dali::BaseHandle arg1 ;
84698   Dali::BaseHandle *argp1 ;
84699   Dali::Toolkit::AsyncImageLoader result;
84700
84701   argp1 = (Dali::BaseHandle *)jarg1;
84702   if (!argp1) {
84703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84704     return 0;
84705   }
84706   arg1 = *argp1;
84707   {
84708     try {
84709       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
84710     } catch (std::out_of_range& e) {
84711       {
84712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84713       };
84714     } catch (std::exception& e) {
84715       {
84716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84717       };
84718     } catch (...) {
84719       {
84720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84721       };
84722     }
84723   }
84724   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
84725   return jresult;
84726 }
84727
84728
84729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
84730   unsigned int jresult ;
84731   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84732   std::string *arg2 = 0 ;
84733   uint32_t result;
84734
84735   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84736   if (!jarg2) {
84737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84738     return 0;
84739   }
84740   std::string arg2_str(jarg2);
84741   arg2 = &arg2_str;
84742   {
84743     try {
84744       result = (arg1)->Load((std::string const &)*arg2);
84745     } catch (std::out_of_range& e) {
84746       {
84747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (std::exception& e) {
84750       {
84751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84752       };
84753     } catch (...) {
84754       {
84755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84756       };
84757     }
84758   }
84759   jresult = result;
84760
84761   //argout typemap for const std::string&
84762
84763   return jresult;
84764 }
84765
84766
84767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
84768   unsigned int jresult ;
84769   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84770   std::string *arg2 = 0 ;
84771   Dali::ImageDimensions arg3 ;
84772   Dali::ImageDimensions *argp3 ;
84773   uint32_t result;
84774
84775   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84776   if (!jarg2) {
84777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84778     return 0;
84779   }
84780   std::string arg2_str(jarg2);
84781   arg2 = &arg2_str;
84782   argp3 = (Dali::ImageDimensions *)jarg3;
84783   if (!argp3) {
84784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84785     return 0;
84786   }
84787   arg3 = *argp3;
84788   {
84789     try {
84790       result = (arg1)->Load((std::string const &)*arg2,arg3);
84791     } catch (std::out_of_range& e) {
84792       {
84793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84794       };
84795     } catch (std::exception& e) {
84796       {
84797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84798       };
84799     } catch (...) {
84800       {
84801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84802       };
84803     }
84804   }
84805   jresult = result;
84806
84807   //argout typemap for const std::string&
84808
84809   return jresult;
84810 }
84811
84812
84813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
84814   unsigned int jresult ;
84815   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84816   std::string *arg2 = 0 ;
84817   Dali::ImageDimensions arg3 ;
84818   Dali::FittingMode::Type arg4 ;
84819   Dali::SamplingMode::Type arg5 ;
84820   bool arg6 ;
84821   Dali::ImageDimensions *argp3 ;
84822   uint32_t result;
84823
84824   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84825   if (!jarg2) {
84826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84827     return 0;
84828   }
84829   std::string arg2_str(jarg2);
84830   arg2 = &arg2_str;
84831   argp3 = (Dali::ImageDimensions *)jarg3;
84832   if (!argp3) {
84833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84834     return 0;
84835   }
84836   arg3 = *argp3;
84837   arg4 = (Dali::FittingMode::Type)jarg4;
84838   arg5 = (Dali::SamplingMode::Type)jarg5;
84839   arg6 = jarg6 ? true : false;
84840   {
84841     try {
84842       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
84843     } catch (std::out_of_range& e) {
84844       {
84845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84846       };
84847     } catch (std::exception& e) {
84848       {
84849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84850       };
84851     } catch (...) {
84852       {
84853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84854       };
84855     }
84856   }
84857   jresult = result;
84858
84859   //argout typemap for const std::string&
84860
84861   return jresult;
84862 }
84863
84864
84865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
84866   unsigned int jresult ;
84867   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84868   uint32_t arg2 ;
84869   bool result;
84870
84871   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84872   arg2 = (uint32_t)jarg2;
84873   {
84874     try {
84875       result = (bool)(arg1)->Cancel(arg2);
84876     } catch (std::out_of_range& e) {
84877       {
84878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84879       };
84880     } catch (std::exception& e) {
84881       {
84882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (...) {
84885       {
84886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84887       };
84888     }
84889   }
84890   jresult = result;
84891   return jresult;
84892 }
84893
84894
84895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
84896   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84897
84898   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84899   {
84900     try {
84901       (arg1)->CancelAll();
84902     } catch (std::out_of_range& e) {
84903       {
84904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84905       };
84906     } catch (std::exception& e) {
84907       {
84908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84909       };
84910     } catch (...) {
84911       {
84912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84913       };
84914     }
84915   }
84916 }
84917
84918
84919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
84920   void * jresult ;
84921   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84922   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
84923
84924   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84925   {
84926     try {
84927       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
84928     } catch (std::out_of_range& e) {
84929       {
84930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84931       };
84932     } catch (std::exception& e) {
84933       {
84934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84935       };
84936     } catch (...) {
84937       {
84938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84939       };
84940     }
84941   }
84942   jresult = (void *)result;
84943   return jresult;
84944 }
84945
84946
84947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
84948   void * jresult ;
84949   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
84950   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84951
84952   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
84953   {
84954     try {
84955       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
84956     } catch (std::out_of_range& e) {
84957       {
84958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84959       };
84960     } catch (std::exception& e) {
84961       {
84962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84963       };
84964     } catch (...) {
84965       {
84966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84967       };
84968     }
84969   }
84970   jresult = (void *)result;
84971   return jresult;
84972 }
84973
84974
84975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
84976   void * jresult ;
84977   std::string *arg1 = 0 ;
84978   Dali::PixelData result;
84979
84980   if (!jarg1) {
84981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84982     return 0;
84983   }
84984   std::string arg1_str(jarg1);
84985   arg1 = &arg1_str;
84986   {
84987     try {
84988       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
84989     } catch (std::out_of_range& e) {
84990       {
84991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84992       };
84993     } catch (std::exception& e) {
84994       {
84995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84996       };
84997     } catch (...) {
84998       {
84999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85000       };
85001     }
85002   }
85003   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85004
85005   //argout typemap for const std::string&
85006
85007   return jresult;
85008 }
85009
85010
85011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85012   void * jresult ;
85013   std::string *arg1 = 0 ;
85014   Dali::ImageDimensions arg2 ;
85015   Dali::ImageDimensions *argp2 ;
85016   Dali::PixelData result;
85017
85018   if (!jarg1) {
85019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85020     return 0;
85021   }
85022   std::string arg1_str(jarg1);
85023   arg1 = &arg1_str;
85024   argp2 = (Dali::ImageDimensions *)jarg2;
85025   if (!argp2) {
85026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85027     return 0;
85028   }
85029   arg2 = *argp2;
85030   {
85031     try {
85032       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85033     } catch (std::out_of_range& e) {
85034       {
85035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85036       };
85037     } catch (std::exception& e) {
85038       {
85039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85040       };
85041     } catch (...) {
85042       {
85043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85044       };
85045     }
85046   }
85047   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85048
85049   //argout typemap for const std::string&
85050
85051   return jresult;
85052 }
85053
85054
85055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85056   void * jresult ;
85057   std::string *arg1 = 0 ;
85058   Dali::ImageDimensions arg2 ;
85059   Dali::FittingMode::Type arg3 ;
85060   Dali::SamplingMode::Type arg4 ;
85061   bool arg5 ;
85062   Dali::ImageDimensions *argp2 ;
85063   Dali::PixelData result;
85064
85065   if (!jarg1) {
85066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85067     return 0;
85068   }
85069   std::string arg1_str(jarg1);
85070   arg1 = &arg1_str;
85071   argp2 = (Dali::ImageDimensions *)jarg2;
85072   if (!argp2) {
85073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85074     return 0;
85075   }
85076   arg2 = *argp2;
85077   arg3 = (Dali::FittingMode::Type)jarg3;
85078   arg4 = (Dali::SamplingMode::Type)jarg4;
85079   arg5 = jarg5 ? true : false;
85080   {
85081     try {
85082       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85083     } catch (std::out_of_range& e) {
85084       {
85085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85086       };
85087     } catch (std::exception& e) {
85088       {
85089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85090       };
85091     } catch (...) {
85092       {
85093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85094       };
85095     }
85096   }
85097   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85098
85099   //argout typemap for const std::string&
85100
85101   return jresult;
85102 }
85103
85104
85105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85106   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85107
85108   arg1 = (std::vector< unsigned int > *)jarg1;
85109   {
85110     try {
85111       (arg1)->clear();
85112     } catch (std::out_of_range& e) {
85113       {
85114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85115       };
85116     } catch (std::exception& e) {
85117       {
85118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85119       };
85120     } catch (...) {
85121       {
85122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85123       };
85124     }
85125   }
85126 }
85127
85128
85129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85130   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85131   unsigned int *arg2 = 0 ;
85132   unsigned int temp2 ;
85133
85134   arg1 = (std::vector< unsigned int > *)jarg1;
85135   temp2 = (unsigned int)jarg2;
85136   arg2 = &temp2;
85137   {
85138     try {
85139       (arg1)->push_back((unsigned int const &)*arg2);
85140     } catch (std::out_of_range& e) {
85141       {
85142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85143       };
85144     } catch (std::exception& e) {
85145       {
85146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85147       };
85148     } catch (...) {
85149       {
85150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85151       };
85152     }
85153   }
85154 }
85155
85156
85157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85158   unsigned long jresult ;
85159   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85160   std::vector< unsigned int >::size_type result;
85161
85162   arg1 = (std::vector< unsigned int > *)jarg1;
85163   {
85164     try {
85165       result = ((std::vector< unsigned int > const *)arg1)->size();
85166     } catch (std::out_of_range& e) {
85167       {
85168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85169       };
85170     } catch (std::exception& e) {
85171       {
85172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85173       };
85174     } catch (...) {
85175       {
85176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85177       };
85178     }
85179   }
85180   jresult = (unsigned long)result;
85181   return jresult;
85182 }
85183
85184
85185 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85186   unsigned long jresult ;
85187   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85188   std::vector< unsigned int >::size_type result;
85189
85190   arg1 = (std::vector< unsigned int > *)jarg1;
85191   {
85192     try {
85193       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85194     } catch (std::out_of_range& e) {
85195       {
85196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85197       };
85198     } catch (std::exception& e) {
85199       {
85200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85201       };
85202     } catch (...) {
85203       {
85204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85205       };
85206     }
85207   }
85208   jresult = (unsigned long)result;
85209   return jresult;
85210 }
85211
85212
85213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85214   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85215   std::vector< unsigned int >::size_type arg2 ;
85216
85217   arg1 = (std::vector< unsigned int > *)jarg1;
85218   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85219   {
85220     try {
85221       (arg1)->reserve(arg2);
85222     } catch (std::out_of_range& e) {
85223       {
85224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85225       };
85226     } catch (std::exception& e) {
85227       {
85228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85229       };
85230     } catch (...) {
85231       {
85232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85233       };
85234     }
85235   }
85236 }
85237
85238
85239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85240   void * jresult ;
85241   std::vector< unsigned int > *result = 0 ;
85242
85243   {
85244     try {
85245       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85246     } catch (std::out_of_range& e) {
85247       {
85248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85249       };
85250     } catch (std::exception& e) {
85251       {
85252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85253       };
85254     } catch (...) {
85255       {
85256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85257       };
85258     }
85259   }
85260   jresult = (void *)result;
85261   return jresult;
85262 }
85263
85264
85265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
85266   void * jresult ;
85267   std::vector< unsigned int > *arg1 = 0 ;
85268   std::vector< unsigned int > *result = 0 ;
85269
85270   arg1 = (std::vector< unsigned int > *)jarg1;
85271   if (!arg1) {
85272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85273     return 0;
85274   }
85275   {
85276     try {
85277       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
85278     } catch (std::out_of_range& e) {
85279       {
85280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85281       };
85282     } catch (std::exception& e) {
85283       {
85284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85285       };
85286     } catch (...) {
85287       {
85288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85289       };
85290     }
85291   }
85292   jresult = (void *)result;
85293   return jresult;
85294 }
85295
85296
85297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
85298   void * jresult ;
85299   int arg1 ;
85300   std::vector< unsigned int > *result = 0 ;
85301
85302   arg1 = (int)jarg1;
85303   {
85304     try {
85305       try {
85306         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
85307       }
85308       catch(std::out_of_range &_e) {
85309         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85310         return 0;
85311       }
85312
85313     } catch (std::out_of_range& e) {
85314       {
85315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85316       };
85317     } catch (std::exception& e) {
85318       {
85319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85320       };
85321     } catch (...) {
85322       {
85323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85324       };
85325     }
85326   }
85327   jresult = (void *)result;
85328   return jresult;
85329 }
85330
85331
85332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
85333   unsigned int jresult ;
85334   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85335   int arg2 ;
85336   unsigned int result;
85337
85338   arg1 = (std::vector< unsigned int > *)jarg1;
85339   arg2 = (int)jarg2;
85340   {
85341     try {
85342       try {
85343         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
85344       }
85345       catch(std::out_of_range &_e) {
85346         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85347         return 0;
85348       }
85349
85350     } catch (std::out_of_range& e) {
85351       {
85352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85353       };
85354     } catch (std::exception& e) {
85355       {
85356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85357       };
85358     } catch (...) {
85359       {
85360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85361       };
85362     }
85363   }
85364   jresult = result;
85365   return jresult;
85366 }
85367
85368
85369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
85370   unsigned int jresult ;
85371   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85372   int arg2 ;
85373   unsigned int *result = 0 ;
85374
85375   arg1 = (std::vector< unsigned int > *)jarg1;
85376   arg2 = (int)jarg2;
85377   {
85378     try {
85379       try {
85380         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
85381       }
85382       catch(std::out_of_range &_e) {
85383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85384         return 0;
85385       }
85386
85387     } catch (std::out_of_range& e) {
85388       {
85389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85390       };
85391     } catch (std::exception& e) {
85392       {
85393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85394       };
85395     } catch (...) {
85396       {
85397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85398       };
85399     }
85400   }
85401   jresult = *result;
85402   return jresult;
85403 }
85404
85405
85406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
85407   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85408   int arg2 ;
85409   unsigned int *arg3 = 0 ;
85410   unsigned int temp3 ;
85411
85412   arg1 = (std::vector< unsigned int > *)jarg1;
85413   arg2 = (int)jarg2;
85414   temp3 = (unsigned int)jarg3;
85415   arg3 = &temp3;
85416   {
85417     try {
85418       try {
85419         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
85420       }
85421       catch(std::out_of_range &_e) {
85422         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85423         return ;
85424       }
85425
85426     } catch (std::out_of_range& e) {
85427       {
85428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85429       };
85430     } catch (std::exception& e) {
85431       {
85432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85433       };
85434     } catch (...) {
85435       {
85436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85437       };
85438     }
85439   }
85440 }
85441
85442
85443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
85444   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85445   std::vector< unsigned int > *arg2 = 0 ;
85446
85447   arg1 = (std::vector< unsigned int > *)jarg1;
85448   arg2 = (std::vector< unsigned int > *)jarg2;
85449   if (!arg2) {
85450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85451     return ;
85452   }
85453   {
85454     try {
85455       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
85456     } catch (std::out_of_range& e) {
85457       {
85458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85459       };
85460     } catch (std::exception& e) {
85461       {
85462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85463       };
85464     } catch (...) {
85465       {
85466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85467       };
85468     }
85469   }
85470 }
85471
85472
85473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
85474   void * jresult ;
85475   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85476   int arg2 ;
85477   int arg3 ;
85478   std::vector< unsigned int > *result = 0 ;
85479
85480   arg1 = (std::vector< unsigned int > *)jarg1;
85481   arg2 = (int)jarg2;
85482   arg3 = (int)jarg3;
85483   {
85484     try {
85485       try {
85486         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
85487       }
85488       catch(std::out_of_range &_e) {
85489         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85490         return 0;
85491       }
85492       catch(std::invalid_argument &_e) {
85493         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
85494         return 0;
85495       }
85496
85497     } catch (std::out_of_range& e) {
85498       {
85499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85500       };
85501     } catch (std::exception& e) {
85502       {
85503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85504       };
85505     } catch (...) {
85506       {
85507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85508       };
85509     }
85510   }
85511   jresult = (void *)result;
85512   return jresult;
85513 }
85514
85515
85516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
85517   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85518   int arg2 ;
85519   unsigned int *arg3 = 0 ;
85520   unsigned int temp3 ;
85521
85522   arg1 = (std::vector< unsigned int > *)jarg1;
85523   arg2 = (int)jarg2;
85524   temp3 = (unsigned int)jarg3;
85525   arg3 = &temp3;
85526   {
85527     try {
85528       try {
85529         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
85530       }
85531       catch(std::out_of_range &_e) {
85532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85533         return ;
85534       }
85535
85536     } catch (std::out_of_range& e) {
85537       {
85538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85539       };
85540     } catch (std::exception& e) {
85541       {
85542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85543       };
85544     } catch (...) {
85545       {
85546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85547       };
85548     }
85549   }
85550 }
85551
85552
85553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
85554   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85555   int arg2 ;
85556   std::vector< unsigned int > *arg3 = 0 ;
85557
85558   arg1 = (std::vector< unsigned int > *)jarg1;
85559   arg2 = (int)jarg2;
85560   arg3 = (std::vector< unsigned int > *)jarg3;
85561   if (!arg3) {
85562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85563     return ;
85564   }
85565   {
85566     try {
85567       try {
85568         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
85569       }
85570       catch(std::out_of_range &_e) {
85571         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85572         return ;
85573       }
85574
85575     } catch (std::out_of_range& e) {
85576       {
85577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85578       };
85579     } catch (std::exception& e) {
85580       {
85581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85582       };
85583     } catch (...) {
85584       {
85585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85586       };
85587     }
85588   }
85589 }
85590
85591
85592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
85593   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85594   int arg2 ;
85595
85596   arg1 = (std::vector< unsigned int > *)jarg1;
85597   arg2 = (int)jarg2;
85598   {
85599     try {
85600       try {
85601         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
85602       }
85603       catch(std::out_of_range &_e) {
85604         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85605         return ;
85606       }
85607
85608     } catch (std::out_of_range& e) {
85609       {
85610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85611       };
85612     } catch (std::exception& e) {
85613       {
85614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85615       };
85616     } catch (...) {
85617       {
85618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85619       };
85620     }
85621   }
85622 }
85623
85624
85625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
85626   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85627   int arg2 ;
85628   int arg3 ;
85629
85630   arg1 = (std::vector< unsigned int > *)jarg1;
85631   arg2 = (int)jarg2;
85632   arg3 = (int)jarg3;
85633   {
85634     try {
85635       try {
85636         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
85637       }
85638       catch(std::out_of_range &_e) {
85639         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85640         return ;
85641       }
85642       catch(std::invalid_argument &_e) {
85643         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
85644         return ;
85645       }
85646
85647     } catch (std::out_of_range& e) {
85648       {
85649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85650       };
85651     } catch (std::exception& e) {
85652       {
85653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85654       };
85655     } catch (...) {
85656       {
85657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85658       };
85659     }
85660   }
85661 }
85662
85663
85664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
85665   void * jresult ;
85666   unsigned int *arg1 = 0 ;
85667   int arg2 ;
85668   unsigned int temp1 ;
85669   std::vector< unsigned int > *result = 0 ;
85670
85671   temp1 = (unsigned int)jarg1;
85672   arg1 = &temp1;
85673   arg2 = (int)jarg2;
85674   {
85675     try {
85676       try {
85677         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
85678       }
85679       catch(std::out_of_range &_e) {
85680         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85681         return 0;
85682       }
85683
85684     } catch (std::out_of_range& e) {
85685       {
85686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85687       };
85688     } catch (std::exception& e) {
85689       {
85690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85691       };
85692     } catch (...) {
85693       {
85694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85695       };
85696     }
85697   }
85698   jresult = (void *)result;
85699   return jresult;
85700 }
85701
85702
85703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
85704   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85705
85706   arg1 = (std::vector< unsigned int > *)jarg1;
85707   {
85708     try {
85709       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
85710     } catch (std::out_of_range& e) {
85711       {
85712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85713       };
85714     } catch (std::exception& e) {
85715       {
85716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85717       };
85718     } catch (...) {
85719       {
85720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85721       };
85722     }
85723   }
85724 }
85725
85726
85727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
85728   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85729   int arg2 ;
85730   int arg3 ;
85731
85732   arg1 = (std::vector< unsigned int > *)jarg1;
85733   arg2 = (int)jarg2;
85734   arg3 = (int)jarg3;
85735   {
85736     try {
85737       try {
85738         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
85739       }
85740       catch(std::out_of_range &_e) {
85741         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85742         return ;
85743       }
85744       catch(std::invalid_argument &_e) {
85745         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
85746         return ;
85747       }
85748
85749     } catch (std::out_of_range& e) {
85750       {
85751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85752       };
85753     } catch (std::exception& e) {
85754       {
85755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85756       };
85757     } catch (...) {
85758       {
85759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85760       };
85761     }
85762   }
85763 }
85764
85765
85766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
85767   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85768   int arg2 ;
85769   std::vector< unsigned int > *arg3 = 0 ;
85770
85771   arg1 = (std::vector< unsigned int > *)jarg1;
85772   arg2 = (int)jarg2;
85773   arg3 = (std::vector< unsigned int > *)jarg3;
85774   if (!arg3) {
85775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85776     return ;
85777   }
85778   {
85779     try {
85780       try {
85781         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
85782       }
85783       catch(std::out_of_range &_e) {
85784         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85785         return ;
85786       }
85787
85788     } catch (std::out_of_range& e) {
85789       {
85790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85791       };
85792     } catch (std::exception& e) {
85793       {
85794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85795       };
85796     } catch (...) {
85797       {
85798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85799       };
85800     }
85801   }
85802 }
85803
85804
85805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
85806   unsigned int jresult ;
85807   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85808   unsigned int *arg2 = 0 ;
85809   unsigned int temp2 ;
85810   bool result;
85811
85812   arg1 = (std::vector< unsigned int > *)jarg1;
85813   temp2 = (unsigned int)jarg2;
85814   arg2 = &temp2;
85815   {
85816     try {
85817       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
85818     } catch (std::out_of_range& e) {
85819       {
85820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85821       };
85822     } catch (std::exception& e) {
85823       {
85824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85825       };
85826     } catch (...) {
85827       {
85828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85829       };
85830     }
85831   }
85832   jresult = result;
85833   return jresult;
85834 }
85835
85836
85837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
85838   int jresult ;
85839   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85840   unsigned int *arg2 = 0 ;
85841   unsigned int temp2 ;
85842   int result;
85843
85844   arg1 = (std::vector< unsigned int > *)jarg1;
85845   temp2 = (unsigned int)jarg2;
85846   arg2 = &temp2;
85847   {
85848     try {
85849       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
85850     } catch (std::out_of_range& e) {
85851       {
85852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (std::exception& e) {
85855       {
85856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85857       };
85858     } catch (...) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85861       };
85862     }
85863   }
85864   jresult = result;
85865   return jresult;
85866 }
85867
85868
85869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
85870   int jresult ;
85871   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85872   unsigned int *arg2 = 0 ;
85873   unsigned int temp2 ;
85874   int result;
85875
85876   arg1 = (std::vector< unsigned int > *)jarg1;
85877   temp2 = (unsigned int)jarg2;
85878   arg2 = &temp2;
85879   {
85880     try {
85881       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
85882     } catch (std::out_of_range& e) {
85883       {
85884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85885       };
85886     } catch (std::exception& e) {
85887       {
85888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85889       };
85890     } catch (...) {
85891       {
85892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85893       };
85894     }
85895   }
85896   jresult = result;
85897   return jresult;
85898 }
85899
85900
85901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
85902   unsigned int jresult ;
85903   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85904   unsigned int *arg2 = 0 ;
85905   unsigned int temp2 ;
85906   bool result;
85907
85908   arg1 = (std::vector< unsigned int > *)jarg1;
85909   temp2 = (unsigned int)jarg2;
85910   arg2 = &temp2;
85911   {
85912     try {
85913       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
85914     } catch (std::out_of_range& e) {
85915       {
85916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85917       };
85918     } catch (std::exception& e) {
85919       {
85920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85921       };
85922     } catch (...) {
85923       {
85924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85925       };
85926     }
85927   }
85928   jresult = result;
85929   return jresult;
85930 }
85931
85932
85933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
85934   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85935
85936   arg1 = (std::vector< unsigned int > *)jarg1;
85937   {
85938     try {
85939       delete arg1;
85940     } catch (std::out_of_range& e) {
85941       {
85942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85943       };
85944     } catch (std::exception& e) {
85945       {
85946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85947       };
85948     } catch (...) {
85949       {
85950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85951       };
85952     }
85953   }
85954 }
85955
85956
85957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
85958   void * jresult ;
85959   std::pair< unsigned int,Dali::Actor > *result = 0 ;
85960
85961   {
85962     try {
85963       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
85964     } catch (std::out_of_range& e) {
85965       {
85966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85967       };
85968     } catch (std::exception& e) {
85969       {
85970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85971       };
85972     } catch (...) {
85973       {
85974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85975       };
85976     }
85977   }
85978   jresult = (void *)result;
85979   return jresult;
85980 }
85981
85982
85983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
85984   void * jresult ;
85985   unsigned int arg1 ;
85986   Dali::Actor arg2 ;
85987   Dali::Actor *argp2 ;
85988   std::pair< unsigned int,Dali::Actor > *result = 0 ;
85989
85990   arg1 = (unsigned int)jarg1;
85991   argp2 = (Dali::Actor *)jarg2;
85992   if (!argp2) {
85993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85994     return 0;
85995   }
85996   arg2 = *argp2;
85997   {
85998     try {
85999       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86000     } catch (std::out_of_range& e) {
86001       {
86002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86003       };
86004     } catch (std::exception& e) {
86005       {
86006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86007       };
86008     } catch (...) {
86009       {
86010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86011       };
86012     }
86013   }
86014   jresult = (void *)result;
86015   return jresult;
86016 }
86017
86018
86019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86020   void * jresult ;
86021   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86022   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86023
86024   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86025   if (!arg1) {
86026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86027     return 0;
86028   }
86029   {
86030     try {
86031       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86032     } catch (std::out_of_range& e) {
86033       {
86034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86035       };
86036     } catch (std::exception& e) {
86037       {
86038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86039       };
86040     } catch (...) {
86041       {
86042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86043       };
86044     }
86045   }
86046   jresult = (void *)result;
86047   return jresult;
86048 }
86049
86050
86051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86052   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86053   unsigned int arg2 ;
86054
86055   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86056   arg2 = (unsigned int)jarg2;
86057   if (arg1) (arg1)->first = arg2;
86058 }
86059
86060
86061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86062   unsigned int jresult ;
86063   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86064   unsigned int result;
86065
86066   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86067   result = (unsigned int) ((arg1)->first);
86068   jresult = result;
86069   return jresult;
86070 }
86071
86072
86073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86074   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86075   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86076
86077   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86078   arg2 = (Dali::Actor *)jarg2;
86079   if (arg1) (arg1)->second = *arg2;
86080 }
86081
86082
86083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86084   void * jresult ;
86085   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86086   Dali::Actor *result = 0 ;
86087
86088   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86089   result = (Dali::Actor *)& ((arg1)->second);
86090   jresult = (void *)result;
86091   return jresult;
86092 }
86093
86094
86095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86096   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86097
86098   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86099   {
86100     try {
86101       delete arg1;
86102     } catch (std::out_of_range& e) {
86103       {
86104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86105       };
86106     } catch (std::exception& e) {
86107       {
86108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86109       };
86110     } catch (...) {
86111       {
86112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86113       };
86114     }
86115   }
86116 }
86117
86118
86119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86120   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86121
86122   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86123   {
86124     try {
86125       (arg1)->clear();
86126     } catch (std::out_of_range& e) {
86127       {
86128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86129       };
86130     } catch (std::exception& e) {
86131       {
86132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86133       };
86134     } catch (...) {
86135       {
86136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86137       };
86138     }
86139   }
86140 }
86141
86142
86143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86144   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86145   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86146
86147   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86148   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86149   if (!arg2) {
86150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86151     return ;
86152   }
86153   {
86154     try {
86155       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86156     } catch (std::out_of_range& e) {
86157       {
86158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86159       };
86160     } catch (std::exception& e) {
86161       {
86162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86163       };
86164     } catch (...) {
86165       {
86166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86167       };
86168     }
86169   }
86170 }
86171
86172
86173 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86174   unsigned long jresult ;
86175   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86176   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86177
86178   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86179   {
86180     try {
86181       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86182     } catch (std::out_of_range& e) {
86183       {
86184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86185       };
86186     } catch (std::exception& e) {
86187       {
86188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86189       };
86190     } catch (...) {
86191       {
86192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86193       };
86194     }
86195   }
86196   jresult = (unsigned long)result;
86197   return jresult;
86198 }
86199
86200
86201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86202   unsigned long jresult ;
86203   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86204   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86205
86206   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86207   {
86208     try {
86209       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86210     } catch (std::out_of_range& e) {
86211       {
86212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86213       };
86214     } catch (std::exception& e) {
86215       {
86216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86217       };
86218     } catch (...) {
86219       {
86220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86221       };
86222     }
86223   }
86224   jresult = (unsigned long)result;
86225   return jresult;
86226 }
86227
86228
86229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86230   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86231   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86232
86233   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86234   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86235   {
86236     try {
86237       (arg1)->reserve(arg2);
86238     } catch (std::out_of_range& e) {
86239       {
86240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86241       };
86242     } catch (std::exception& e) {
86243       {
86244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86245       };
86246     } catch (...) {
86247       {
86248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86249       };
86250     }
86251   }
86252 }
86253
86254
86255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86256   void * jresult ;
86257   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86258
86259   {
86260     try {
86261       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86262     } catch (std::out_of_range& e) {
86263       {
86264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86265       };
86266     } catch (std::exception& e) {
86267       {
86268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86269       };
86270     } catch (...) {
86271       {
86272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86273       };
86274     }
86275   }
86276   jresult = (void *)result;
86277   return jresult;
86278 }
86279
86280
86281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
86282   void * jresult ;
86283   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
86284   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86285
86286   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86287   if (!arg1) {
86288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86289     return 0;
86290   }
86291   {
86292     try {
86293       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);
86294     } catch (std::out_of_range& e) {
86295       {
86296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86297       };
86298     } catch (std::exception& e) {
86299       {
86300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86301       };
86302     } catch (...) {
86303       {
86304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86305       };
86306     }
86307   }
86308   jresult = (void *)result;
86309   return jresult;
86310 }
86311
86312
86313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
86314   void * jresult ;
86315   int arg1 ;
86316   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86317
86318   arg1 = (int)jarg1;
86319   {
86320     try {
86321       try {
86322         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);
86323       }
86324       catch(std::out_of_range &_e) {
86325         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86326         return 0;
86327       }
86328
86329     } catch (std::out_of_range& e) {
86330       {
86331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86332       };
86333     } catch (std::exception& e) {
86334       {
86335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86336       };
86337     } catch (...) {
86338       {
86339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86340       };
86341     }
86342   }
86343   jresult = (void *)result;
86344   return jresult;
86345 }
86346
86347
86348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
86349   void * jresult ;
86350   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86351   int arg2 ;
86352   std::pair< unsigned int,Dali::Actor > result;
86353
86354   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86355   arg2 = (int)jarg2;
86356   {
86357     try {
86358       try {
86359         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
86360       }
86361       catch(std::out_of_range &_e) {
86362         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86363         return 0;
86364       }
86365
86366     } catch (std::out_of_range& e) {
86367       {
86368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86369       };
86370     } catch (std::exception& e) {
86371       {
86372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86373       };
86374     } catch (...) {
86375       {
86376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86377       };
86378     }
86379   }
86380   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
86381   return jresult;
86382 }
86383
86384
86385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
86386   void * jresult ;
86387   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86388   int arg2 ;
86389   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86390
86391   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86392   arg2 = (int)jarg2;
86393   {
86394     try {
86395       try {
86396         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
86397       }
86398       catch(std::out_of_range &_e) {
86399         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86400         return 0;
86401       }
86402
86403     } catch (std::out_of_range& e) {
86404       {
86405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86406       };
86407     } catch (std::exception& e) {
86408       {
86409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86410       };
86411     } catch (...) {
86412       {
86413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86414       };
86415     }
86416   }
86417   jresult = (void *)result;
86418   return jresult;
86419 }
86420
86421
86422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
86423   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86424   int arg2 ;
86425   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
86426
86427   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86428   arg2 = (int)jarg2;
86429   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
86430   if (!arg3) {
86431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86432     return ;
86433   }
86434   {
86435     try {
86436       try {
86437         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);
86438       }
86439       catch(std::out_of_range &_e) {
86440         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86441         return ;
86442       }
86443
86444     } catch (std::out_of_range& e) {
86445       {
86446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86447       };
86448     } catch (std::exception& e) {
86449       {
86450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86451       };
86452     } catch (...) {
86453       {
86454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86455       };
86456     }
86457   }
86458 }
86459
86460
86461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
86462   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86463   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
86464
86465   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86466   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
86467   if (!arg2) {
86468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86469     return ;
86470   }
86471   {
86472     try {
86473       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);
86474     } catch (std::out_of_range& e) {
86475       {
86476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86477       };
86478     } catch (std::exception& e) {
86479       {
86480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86481       };
86482     } catch (...) {
86483       {
86484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86485       };
86486     }
86487   }
86488 }
86489
86490
86491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86492   void * jresult ;
86493   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86494   int arg2 ;
86495   int arg3 ;
86496   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86497
86498   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86499   arg2 = (int)jarg2;
86500   arg3 = (int)jarg3;
86501   {
86502     try {
86503       try {
86504         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);
86505       }
86506       catch(std::out_of_range &_e) {
86507         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86508         return 0;
86509       }
86510       catch(std::invalid_argument &_e) {
86511         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86512         return 0;
86513       }
86514
86515     } catch (std::out_of_range& e) {
86516       {
86517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86518       };
86519     } catch (std::exception& e) {
86520       {
86521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86522       };
86523     } catch (...) {
86524       {
86525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86526       };
86527     }
86528   }
86529   jresult = (void *)result;
86530   return jresult;
86531 }
86532
86533
86534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
86535   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86536   int arg2 ;
86537   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
86538
86539   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86540   arg2 = (int)jarg2;
86541   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
86542   if (!arg3) {
86543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86544     return ;
86545   }
86546   {
86547     try {
86548       try {
86549         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);
86550       }
86551       catch(std::out_of_range &_e) {
86552         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86553         return ;
86554       }
86555
86556     } catch (std::out_of_range& e) {
86557       {
86558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86559       };
86560     } catch (std::exception& e) {
86561       {
86562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86563       };
86564     } catch (...) {
86565       {
86566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86567       };
86568     }
86569   }
86570 }
86571
86572
86573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86574   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86575   int arg2 ;
86576   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
86577
86578   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86579   arg2 = (int)jarg2;
86580   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
86581   if (!arg3) {
86582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86583     return ;
86584   }
86585   {
86586     try {
86587       try {
86588         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);
86589       }
86590       catch(std::out_of_range &_e) {
86591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86592         return ;
86593       }
86594
86595     } catch (std::out_of_range& e) {
86596       {
86597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86598       };
86599     } catch (std::exception& e) {
86600       {
86601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86602       };
86603     } catch (...) {
86604       {
86605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86606       };
86607     }
86608   }
86609 }
86610
86611
86612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
86613   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86614   int arg2 ;
86615
86616   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86617   arg2 = (int)jarg2;
86618   {
86619     try {
86620       try {
86621         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
86622       }
86623       catch(std::out_of_range &_e) {
86624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86625         return ;
86626       }
86627
86628     } catch (std::out_of_range& e) {
86629       {
86630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86631       };
86632     } catch (std::exception& e) {
86633       {
86634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86635       };
86636     } catch (...) {
86637       {
86638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86639       };
86640     }
86641   }
86642 }
86643
86644
86645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86646   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86647   int arg2 ;
86648   int arg3 ;
86649
86650   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86651   arg2 = (int)jarg2;
86652   arg3 = (int)jarg3;
86653   {
86654     try {
86655       try {
86656         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
86657       }
86658       catch(std::out_of_range &_e) {
86659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86660         return ;
86661       }
86662       catch(std::invalid_argument &_e) {
86663         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86664         return ;
86665       }
86666
86667     } catch (std::out_of_range& e) {
86668       {
86669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86670       };
86671     } catch (std::exception& e) {
86672       {
86673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86674       };
86675     } catch (...) {
86676       {
86677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86678       };
86679     }
86680   }
86681 }
86682
86683
86684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
86685   void * jresult ;
86686   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86687   int arg2 ;
86688   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86689
86690   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86691   if (!arg1) {
86692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86693     return 0;
86694   }
86695   arg2 = (int)jarg2;
86696   {
86697     try {
86698       try {
86699         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);
86700       }
86701       catch(std::out_of_range &_e) {
86702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86703         return 0;
86704       }
86705
86706     } catch (std::out_of_range& e) {
86707       {
86708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86709       };
86710     } catch (std::exception& e) {
86711       {
86712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86713       };
86714     } catch (...) {
86715       {
86716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86717       };
86718     }
86719   }
86720   jresult = (void *)result;
86721   return jresult;
86722 }
86723
86724
86725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
86726   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86727
86728   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86729   {
86730     try {
86731       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
86732     } catch (std::out_of_range& e) {
86733       {
86734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86735       };
86736     } catch (std::exception& e) {
86737       {
86738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86739       };
86740     } catch (...) {
86741       {
86742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86743       };
86744     }
86745   }
86746 }
86747
86748
86749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86750   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86751   int arg2 ;
86752   int arg3 ;
86753
86754   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86755   arg2 = (int)jarg2;
86756   arg3 = (int)jarg3;
86757   {
86758     try {
86759       try {
86760         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86761       }
86762       catch(std::out_of_range &_e) {
86763         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86764         return ;
86765       }
86766       catch(std::invalid_argument &_e) {
86767         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86768         return ;
86769       }
86770
86771     } catch (std::out_of_range& e) {
86772       {
86773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86774       };
86775     } catch (std::exception& e) {
86776       {
86777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86778       };
86779     } catch (...) {
86780       {
86781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86782       };
86783     }
86784   }
86785 }
86786
86787
86788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86789   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86790   int arg2 ;
86791   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
86792
86793   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86794   arg2 = (int)jarg2;
86795   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
86796   if (!arg3) {
86797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86798     return ;
86799   }
86800   {
86801     try {
86802       try {
86803         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);
86804       }
86805       catch(std::out_of_range &_e) {
86806         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86807         return ;
86808       }
86809
86810     } catch (std::out_of_range& e) {
86811       {
86812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86813       };
86814     } catch (std::exception& e) {
86815       {
86816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86817       };
86818     } catch (...) {
86819       {
86820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86821       };
86822     }
86823   }
86824 }
86825
86826
86827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
86828   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86829
86830   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86831   {
86832     try {
86833       delete arg1;
86834     } catch (std::out_of_range& e) {
86835       {
86836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86837       };
86838     } catch (std::exception& e) {
86839       {
86840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86841       };
86842     } catch (...) {
86843       {
86844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86845       };
86846     }
86847   }
86848 }
86849
86850
86851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
86852   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86853
86854   arg1 = (std::vector< Dali::Actor > *)jarg1;
86855   {
86856     try {
86857       (arg1)->clear();
86858     } catch (std::out_of_range& e) {
86859       {
86860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86861       };
86862     } catch (std::exception& e) {
86863       {
86864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86865       };
86866     } catch (...) {
86867       {
86868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86869       };
86870     }
86871   }
86872 }
86873
86874
86875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
86876   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86877   Dali::Actor *arg2 = 0 ;
86878
86879   arg1 = (std::vector< Dali::Actor > *)jarg1;
86880   arg2 = (Dali::Actor *)jarg2;
86881   if (!arg2) {
86882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
86883     return ;
86884   }
86885   {
86886     try {
86887       (arg1)->push_back((Dali::Actor const &)*arg2);
86888     } catch (std::out_of_range& e) {
86889       {
86890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86891       };
86892     } catch (std::exception& e) {
86893       {
86894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86895       };
86896     } catch (...) {
86897       {
86898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86899       };
86900     }
86901   }
86902 }
86903
86904
86905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
86906   unsigned long jresult ;
86907   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86908   std::vector< Dali::Actor >::size_type result;
86909
86910   arg1 = (std::vector< Dali::Actor > *)jarg1;
86911   {
86912     try {
86913       result = ((std::vector< Dali::Actor > const *)arg1)->size();
86914     } catch (std::out_of_range& e) {
86915       {
86916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86917       };
86918     } catch (std::exception& e) {
86919       {
86920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86921       };
86922     } catch (...) {
86923       {
86924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86925       };
86926     }
86927   }
86928   jresult = (unsigned long)result;
86929   return jresult;
86930 }
86931
86932
86933 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
86934   unsigned long jresult ;
86935   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86936   std::vector< Dali::Actor >::size_type result;
86937
86938   arg1 = (std::vector< Dali::Actor > *)jarg1;
86939   {
86940     try {
86941       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
86942     } catch (std::out_of_range& e) {
86943       {
86944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86945       };
86946     } catch (std::exception& e) {
86947       {
86948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86949       };
86950     } catch (...) {
86951       {
86952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86953       };
86954     }
86955   }
86956   jresult = (unsigned long)result;
86957   return jresult;
86958 }
86959
86960
86961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
86962   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86963   std::vector< Dali::Actor >::size_type arg2 ;
86964
86965   arg1 = (std::vector< Dali::Actor > *)jarg1;
86966   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
86967   {
86968     try {
86969       (arg1)->reserve(arg2);
86970     } catch (std::out_of_range& e) {
86971       {
86972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86973       };
86974     } catch (std::exception& e) {
86975       {
86976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86977       };
86978     } catch (...) {
86979       {
86980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86981       };
86982     }
86983   }
86984 }
86985
86986
86987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
86988   void * jresult ;
86989   std::vector< Dali::Actor > *result = 0 ;
86990
86991   {
86992     try {
86993       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
86994     } catch (std::out_of_range& e) {
86995       {
86996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86997       };
86998     } catch (std::exception& e) {
86999       {
87000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87001       };
87002     } catch (...) {
87003       {
87004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87005       };
87006     }
87007   }
87008   jresult = (void *)result;
87009   return jresult;
87010 }
87011
87012
87013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87014   void * jresult ;
87015   std::vector< Dali::Actor > *arg1 = 0 ;
87016   std::vector< Dali::Actor > *result = 0 ;
87017
87018   arg1 = (std::vector< Dali::Actor > *)jarg1;
87019   if (!arg1) {
87020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87021     return 0;
87022   }
87023   {
87024     try {
87025       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87026     } catch (std::out_of_range& e) {
87027       {
87028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87029       };
87030     } catch (std::exception& e) {
87031       {
87032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87033       };
87034     } catch (...) {
87035       {
87036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87037       };
87038     }
87039   }
87040   jresult = (void *)result;
87041   return jresult;
87042 }
87043
87044
87045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87046   void * jresult ;
87047   int arg1 ;
87048   std::vector< Dali::Actor > *result = 0 ;
87049
87050   arg1 = (int)jarg1;
87051   {
87052     try {
87053       try {
87054         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87055       }
87056       catch(std::out_of_range &_e) {
87057         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87058         return 0;
87059       }
87060
87061     } catch (std::out_of_range& e) {
87062       {
87063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87064       };
87065     } catch (std::exception& e) {
87066       {
87067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87068       };
87069     } catch (...) {
87070       {
87071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87072       };
87073     }
87074   }
87075   jresult = (void *)result;
87076   return jresult;
87077 }
87078
87079
87080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87081   void * jresult ;
87082   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87083   int arg2 ;
87084   Dali::Actor result;
87085
87086   arg1 = (std::vector< Dali::Actor > *)jarg1;
87087   arg2 = (int)jarg2;
87088   {
87089     try {
87090       try {
87091         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87092       }
87093       catch(std::out_of_range &_e) {
87094         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87095         return 0;
87096       }
87097
87098     } catch (std::out_of_range& e) {
87099       {
87100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87101       };
87102     } catch (std::exception& e) {
87103       {
87104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87105       };
87106     } catch (...) {
87107       {
87108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87109       };
87110     }
87111   }
87112   jresult = new Dali::Actor((const Dali::Actor &)result);
87113   return jresult;
87114 }
87115
87116
87117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87118   void * jresult ;
87119   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87120   int arg2 ;
87121   Dali::Actor *result = 0 ;
87122
87123   arg1 = (std::vector< Dali::Actor > *)jarg1;
87124   arg2 = (int)jarg2;
87125   {
87126     try {
87127       try {
87128         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87129       }
87130       catch(std::out_of_range &_e) {
87131         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87132         return 0;
87133       }
87134
87135     } catch (std::out_of_range& e) {
87136       {
87137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87138       };
87139     } catch (std::exception& e) {
87140       {
87141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87142       };
87143     } catch (...) {
87144       {
87145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87146       };
87147     }
87148   }
87149   jresult = (void *)result;
87150   return jresult;
87151 }
87152
87153
87154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87155   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87156   int arg2 ;
87157   Dali::Actor *arg3 = 0 ;
87158
87159   arg1 = (std::vector< Dali::Actor > *)jarg1;
87160   arg2 = (int)jarg2;
87161   arg3 = (Dali::Actor *)jarg3;
87162   if (!arg3) {
87163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87164     return ;
87165   }
87166   {
87167     try {
87168       try {
87169         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87170       }
87171       catch(std::out_of_range &_e) {
87172         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87173         return ;
87174       }
87175
87176     } catch (std::out_of_range& e) {
87177       {
87178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87179       };
87180     } catch (std::exception& e) {
87181       {
87182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87183       };
87184     } catch (...) {
87185       {
87186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87187       };
87188     }
87189   }
87190 }
87191
87192
87193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87194   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87195   std::vector< Dali::Actor > *arg2 = 0 ;
87196
87197   arg1 = (std::vector< Dali::Actor > *)jarg1;
87198   arg2 = (std::vector< Dali::Actor > *)jarg2;
87199   if (!arg2) {
87200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87201     return ;
87202   }
87203   {
87204     try {
87205       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87206     } catch (std::out_of_range& e) {
87207       {
87208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87209       };
87210     } catch (std::exception& e) {
87211       {
87212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87213       };
87214     } catch (...) {
87215       {
87216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87217       };
87218     }
87219   }
87220 }
87221
87222
87223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87224   void * jresult ;
87225   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87226   int arg2 ;
87227   int arg3 ;
87228   std::vector< Dali::Actor > *result = 0 ;
87229
87230   arg1 = (std::vector< Dali::Actor > *)jarg1;
87231   arg2 = (int)jarg2;
87232   arg3 = (int)jarg3;
87233   {
87234     try {
87235       try {
87236         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87237       }
87238       catch(std::out_of_range &_e) {
87239         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87240         return 0;
87241       }
87242       catch(std::invalid_argument &_e) {
87243         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87244         return 0;
87245       }
87246
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 void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87267   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87268   int arg2 ;
87269   Dali::Actor *arg3 = 0 ;
87270
87271   arg1 = (std::vector< Dali::Actor > *)jarg1;
87272   arg2 = (int)jarg2;
87273   arg3 = (Dali::Actor *)jarg3;
87274   if (!arg3) {
87275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87276     return ;
87277   }
87278   {
87279     try {
87280       try {
87281         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
87282       }
87283       catch(std::out_of_range &_e) {
87284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87285         return ;
87286       }
87287
87288     } catch (std::out_of_range& e) {
87289       {
87290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87291       };
87292     } catch (std::exception& e) {
87293       {
87294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87295       };
87296     } catch (...) {
87297       {
87298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87299       };
87300     }
87301   }
87302 }
87303
87304
87305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87306   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87307   int arg2 ;
87308   std::vector< Dali::Actor > *arg3 = 0 ;
87309
87310   arg1 = (std::vector< Dali::Actor > *)jarg1;
87311   arg2 = (int)jarg2;
87312   arg3 = (std::vector< Dali::Actor > *)jarg3;
87313   if (!arg3) {
87314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87315     return ;
87316   }
87317   {
87318     try {
87319       try {
87320         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87321       }
87322       catch(std::out_of_range &_e) {
87323         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87324         return ;
87325       }
87326
87327     } catch (std::out_of_range& e) {
87328       {
87329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87330       };
87331     } catch (std::exception& e) {
87332       {
87333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87334       };
87335     } catch (...) {
87336       {
87337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87338       };
87339     }
87340   }
87341 }
87342
87343
87344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
87345   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87346   int arg2 ;
87347
87348   arg1 = (std::vector< Dali::Actor > *)jarg1;
87349   arg2 = (int)jarg2;
87350   {
87351     try {
87352       try {
87353         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
87354       }
87355       catch(std::out_of_range &_e) {
87356         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87357         return ;
87358       }
87359
87360     } catch (std::out_of_range& e) {
87361       {
87362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87363       };
87364     } catch (std::exception& e) {
87365       {
87366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87367       };
87368     } catch (...) {
87369       {
87370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87371       };
87372     }
87373   }
87374 }
87375
87376
87377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87378   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87379   int arg2 ;
87380   int arg3 ;
87381
87382   arg1 = (std::vector< Dali::Actor > *)jarg1;
87383   arg2 = (int)jarg2;
87384   arg3 = (int)jarg3;
87385   {
87386     try {
87387       try {
87388         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
87389       }
87390       catch(std::out_of_range &_e) {
87391         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87392         return ;
87393       }
87394       catch(std::invalid_argument &_e) {
87395         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87396         return ;
87397       }
87398
87399     } catch (std::out_of_range& e) {
87400       {
87401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87402       };
87403     } catch (std::exception& e) {
87404       {
87405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87406       };
87407     } catch (...) {
87408       {
87409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87410       };
87411     }
87412   }
87413 }
87414
87415
87416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
87417   void * jresult ;
87418   Dali::Actor *arg1 = 0 ;
87419   int arg2 ;
87420   std::vector< Dali::Actor > *result = 0 ;
87421
87422   arg1 = (Dali::Actor *)jarg1;
87423   if (!arg1) {
87424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87425     return 0;
87426   }
87427   arg2 = (int)jarg2;
87428   {
87429     try {
87430       try {
87431         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
87432       }
87433       catch(std::out_of_range &_e) {
87434         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87435         return 0;
87436       }
87437
87438     } catch (std::out_of_range& e) {
87439       {
87440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87441       };
87442     } catch (std::exception& e) {
87443       {
87444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87445       };
87446     } catch (...) {
87447       {
87448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87449       };
87450     }
87451   }
87452   jresult = (void *)result;
87453   return jresult;
87454 }
87455
87456
87457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
87458   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87459
87460   arg1 = (std::vector< Dali::Actor > *)jarg1;
87461   {
87462     try {
87463       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
87464     } catch (std::out_of_range& e) {
87465       {
87466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87467       };
87468     } catch (std::exception& e) {
87469       {
87470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87471       };
87472     } catch (...) {
87473       {
87474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87475       };
87476     }
87477   }
87478 }
87479
87480
87481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87482   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87483   int arg2 ;
87484   int arg3 ;
87485
87486   arg1 = (std::vector< Dali::Actor > *)jarg1;
87487   arg2 = (int)jarg2;
87488   arg3 = (int)jarg3;
87489   {
87490     try {
87491       try {
87492         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87493       }
87494       catch(std::out_of_range &_e) {
87495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87496         return ;
87497       }
87498       catch(std::invalid_argument &_e) {
87499         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87500         return ;
87501       }
87502
87503     } catch (std::out_of_range& e) {
87504       {
87505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87506       };
87507     } catch (std::exception& e) {
87508       {
87509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87510       };
87511     } catch (...) {
87512       {
87513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87514       };
87515     }
87516   }
87517 }
87518
87519
87520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87521   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87522   int arg2 ;
87523   std::vector< Dali::Actor > *arg3 = 0 ;
87524
87525   arg1 = (std::vector< Dali::Actor > *)jarg1;
87526   arg2 = (int)jarg2;
87527   arg3 = (std::vector< Dali::Actor > *)jarg3;
87528   if (!arg3) {
87529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87530     return ;
87531   }
87532   {
87533     try {
87534       try {
87535         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87536       }
87537       catch(std::out_of_range &_e) {
87538         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87539         return ;
87540       }
87541
87542     } catch (std::out_of_range& e) {
87543       {
87544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87545       };
87546     } catch (std::exception& e) {
87547       {
87548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87549       };
87550     } catch (...) {
87551       {
87552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87553       };
87554     }
87555   }
87556 }
87557
87558
87559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
87560   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87561
87562   arg1 = (std::vector< Dali::Actor > *)jarg1;
87563   {
87564     try {
87565       delete arg1;
87566     } catch (std::out_of_range& e) {
87567       {
87568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87569       };
87570     } catch (std::exception& e) {
87571       {
87572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87573       };
87574     } catch (...) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87577       };
87578     }
87579   }
87580 }
87581
87582
87583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
87584   unsigned int jresult ;
87585   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87586   bool result;
87587
87588   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87589   {
87590     try {
87591       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
87592     } catch (std::out_of_range& e) {
87593       {
87594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87595       };
87596     } catch (std::exception& e) {
87597       {
87598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87599       };
87600     } catch (...) {
87601       {
87602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87603       };
87604     }
87605   }
87606   jresult = result;
87607   return jresult;
87608 }
87609
87610
87611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
87612   unsigned long jresult ;
87613   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87614   std::size_t result;
87615
87616   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87617   {
87618     try {
87619       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
87620     } catch (std::out_of_range& e) {
87621       {
87622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87623       };
87624     } catch (std::exception& e) {
87625       {
87626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87627       };
87628     } catch (...) {
87629       {
87630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87631       };
87632     }
87633   }
87634   jresult = (unsigned long)result;
87635   return jresult;
87636 }
87637
87638
87639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
87640   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87641   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
87642
87643   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87644   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
87645   {
87646     try {
87647       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
87648     } catch (std::out_of_range& e) {
87649       {
87650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87651       };
87652     } catch (std::exception& e) {
87653       {
87654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87655       };
87656     } catch (...) {
87657       {
87658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87659       };
87660     }
87661   }
87662 }
87663
87664
87665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
87666   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87667   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
87668
87669   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87670   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
87671   {
87672     try {
87673       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
87674     } catch (std::out_of_range& e) {
87675       {
87676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87677       };
87678     } catch (std::exception& e) {
87679       {
87680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87681       };
87682     } catch (...) {
87683       {
87684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87685       };
87686     }
87687   }
87688 }
87689
87690
87691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
87692   unsigned int jresult ;
87693   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87694   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
87695   bool result;
87696
87697   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87698   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
87699   if (!arg2) {
87700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
87701     return 0;
87702   }
87703   {
87704     try {
87705       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
87706     } catch (std::out_of_range& e) {
87707       {
87708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87709       };
87710     } catch (std::exception& e) {
87711       {
87712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87713       };
87714     } catch (...) {
87715       {
87716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87717       };
87718     }
87719   }
87720   jresult = result;
87721   return jresult;
87722 }
87723
87724
87725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
87726   void * jresult ;
87727   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
87728
87729   {
87730     try {
87731       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
87732     } catch (std::out_of_range& e) {
87733       {
87734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87735       };
87736     } catch (std::exception& e) {
87737       {
87738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87739       };
87740     } catch (...) {
87741       {
87742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87743       };
87744     }
87745   }
87746   jresult = (void *)result;
87747   return jresult;
87748 }
87749
87750
87751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
87752   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87753
87754   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87755   {
87756     try {
87757       delete arg1;
87758     } catch (std::out_of_range& e) {
87759       {
87760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87761       };
87762     } catch (std::exception& e) {
87763       {
87764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87765       };
87766     } catch (...) {
87767       {
87768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87769       };
87770     }
87771   }
87772 }
87773
87774
87775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
87776   unsigned int jresult ;
87777   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87778   bool result;
87779
87780   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87781   {
87782     try {
87783       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);
87784     } catch (std::out_of_range& e) {
87785       {
87786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87787       };
87788     } catch (std::exception& e) {
87789       {
87790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87791       };
87792     } catch (...) {
87793       {
87794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87795       };
87796     }
87797   }
87798   jresult = result;
87799   return jresult;
87800 }
87801
87802
87803 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
87804   unsigned long jresult ;
87805   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87806   std::size_t result;
87807
87808   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87809   {
87810     try {
87811       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);
87812     } catch (std::out_of_range& e) {
87813       {
87814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87815       };
87816     } catch (std::exception& e) {
87817       {
87818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87819       };
87820     } catch (...) {
87821       {
87822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87823       };
87824     }
87825   }
87826   jresult = (unsigned long)result;
87827   return jresult;
87828 }
87829
87830
87831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
87832   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87833   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
87834
87835   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87836   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
87837   {
87838     try {
87839       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
87840     } catch (std::out_of_range& e) {
87841       {
87842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87843       };
87844     } catch (std::exception& e) {
87845       {
87846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87847       };
87848     } catch (...) {
87849       {
87850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87851       };
87852     }
87853   }
87854 }
87855
87856
87857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
87858   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87859   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
87860
87861   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87862   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
87863   {
87864     try {
87865       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
87866     } catch (std::out_of_range& e) {
87867       {
87868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87869       };
87870     } catch (std::exception& e) {
87871       {
87872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87873       };
87874     } catch (...) {
87875       {
87876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87877       };
87878     }
87879   }
87880 }
87881
87882
87883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
87884   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87885   Dali::Actor arg2 ;
87886   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
87887   Dali::Actor *argp2 ;
87888
87889   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87890   argp2 = (Dali::Actor *)jarg2;
87891   if (!argp2) {
87892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87893     return ;
87894   }
87895   arg2 = *argp2;
87896   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
87897   {
87898     try {
87899       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
87900     } catch (std::out_of_range& e) {
87901       {
87902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87903       };
87904     } catch (std::exception& e) {
87905       {
87906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87907       };
87908     } catch (...) {
87909       {
87910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87911       };
87912     }
87913   }
87914 }
87915
87916
87917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
87918   void * jresult ;
87919   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
87920
87921   {
87922     try {
87923       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
87924     } catch (std::out_of_range& e) {
87925       {
87926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87927       };
87928     } catch (std::exception& e) {
87929       {
87930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87931       };
87932     } catch (...) {
87933       {
87934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87935       };
87936     }
87937   }
87938   jresult = (void *)result;
87939   return jresult;
87940 }
87941
87942
87943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
87944   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87945
87946   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87947   {
87948     try {
87949       delete arg1;
87950     } catch (std::out_of_range& e) {
87951       {
87952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87953       };
87954     } catch (std::exception& e) {
87955       {
87956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87957       };
87958     } catch (...) {
87959       {
87960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87961       };
87962     }
87963   }
87964 }
87965
87966
87967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
87968   unsigned int jresult ;
87969   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
87970   bool result;
87971
87972   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
87973   {
87974     try {
87975       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
87976     } catch (std::out_of_range& e) {
87977       {
87978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87979       };
87980     } catch (std::exception& e) {
87981       {
87982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87983       };
87984     } catch (...) {
87985       {
87986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87987       };
87988     }
87989   }
87990   jresult = result;
87991   return jresult;
87992 }
87993
87994
87995 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
87996   unsigned long jresult ;
87997   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
87998   std::size_t result;
87999
88000   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88001   {
88002     try {
88003       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88004     } catch (std::out_of_range& e) {
88005       {
88006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88007       };
88008     } catch (std::exception& e) {
88009       {
88010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88011       };
88012     } catch (...) {
88013       {
88014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88015       };
88016     }
88017   }
88018   jresult = (unsigned long)result;
88019   return jresult;
88020 }
88021
88022
88023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88024   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88025   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88026
88027   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88028   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88029   {
88030     try {
88031       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88032     } catch (std::out_of_range& e) {
88033       {
88034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88035       };
88036     } catch (std::exception& e) {
88037       {
88038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88039       };
88040     } catch (...) {
88041       {
88042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88043       };
88044     }
88045   }
88046 }
88047
88048
88049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88050   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88051   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88052
88053   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88054   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88055   {
88056     try {
88057       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88058     } catch (std::out_of_range& e) {
88059       {
88060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88061       };
88062     } catch (std::exception& e) {
88063       {
88064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88065       };
88066     } catch (...) {
88067       {
88068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88069       };
88070     }
88071   }
88072 }
88073
88074
88075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88076   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88077   Dali::Actor arg2 ;
88078   Dali::Actor arg3 ;
88079   Dali::Actor *argp2 ;
88080   Dali::Actor *argp3 ;
88081
88082   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88083   argp2 = (Dali::Actor *)jarg2;
88084   if (!argp2) {
88085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88086     return ;
88087   }
88088   arg2 = *argp2;
88089   argp3 = (Dali::Actor *)jarg3;
88090   if (!argp3) {
88091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88092     return ;
88093   }
88094   arg3 = *argp3;
88095   {
88096     try {
88097       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88098     } catch (std::out_of_range& e) {
88099       {
88100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88101       };
88102     } catch (std::exception& e) {
88103       {
88104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88105       };
88106     } catch (...) {
88107       {
88108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88109       };
88110     }
88111   }
88112 }
88113
88114
88115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88116   void * jresult ;
88117   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88118
88119   {
88120     try {
88121       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88122     } catch (std::out_of_range& e) {
88123       {
88124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88125       };
88126     } catch (std::exception& e) {
88127       {
88128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88129       };
88130     } catch (...) {
88131       {
88132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88133       };
88134     }
88135   }
88136   jresult = (void *)result;
88137   return jresult;
88138 }
88139
88140
88141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88142   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88143
88144   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88145   {
88146     try {
88147       delete arg1;
88148     } catch (std::out_of_range& e) {
88149       {
88150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88151       };
88152     } catch (std::exception& e) {
88153       {
88154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88155       };
88156     } catch (...) {
88157       {
88158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88159       };
88160     }
88161   }
88162 }
88163
88164
88165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88166   unsigned int jresult ;
88167   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88168   bool result;
88169
88170   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88171   {
88172     try {
88173       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88174     } catch (std::out_of_range& e) {
88175       {
88176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88177       };
88178     } catch (std::exception& e) {
88179       {
88180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88181       };
88182     } catch (...) {
88183       {
88184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88185       };
88186     }
88187   }
88188   jresult = result;
88189   return jresult;
88190 }
88191
88192
88193 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88194   unsigned long jresult ;
88195   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88196   std::size_t result;
88197
88198   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88199   {
88200     try {
88201       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88202     } catch (std::out_of_range& e) {
88203       {
88204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88205       };
88206     } catch (std::exception& e) {
88207       {
88208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88209       };
88210     } catch (...) {
88211       {
88212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88213       };
88214     }
88215   }
88216   jresult = (unsigned long)result;
88217   return jresult;
88218 }
88219
88220
88221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88222   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88223   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88224
88225   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88226   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88227   {
88228     try {
88229       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88230     } catch (std::out_of_range& e) {
88231       {
88232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88233       };
88234     } catch (std::exception& e) {
88235       {
88236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88237       };
88238     } catch (...) {
88239       {
88240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88241       };
88242     }
88243   }
88244 }
88245
88246
88247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88248   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88249   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88250
88251   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88252   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88253   {
88254     try {
88255       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88256     } catch (std::out_of_range& e) {
88257       {
88258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88259       };
88260     } catch (std::exception& e) {
88261       {
88262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88263       };
88264     } catch (...) {
88265       {
88266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88267       };
88268     }
88269   }
88270 }
88271
88272
88273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
88274   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88275   Dali::Actor arg2 ;
88276   bool arg3 ;
88277   Dali::Actor *argp2 ;
88278
88279   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88280   argp2 = (Dali::Actor *)jarg2;
88281   if (!argp2) {
88282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88283     return ;
88284   }
88285   arg2 = *argp2;
88286   arg3 = jarg3 ? true : false;
88287   {
88288     try {
88289       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
88290     } catch (std::out_of_range& e) {
88291       {
88292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88293       };
88294     } catch (std::exception& e) {
88295       {
88296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88297       };
88298     } catch (...) {
88299       {
88300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88301       };
88302     }
88303   }
88304 }
88305
88306
88307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
88308   void * jresult ;
88309   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
88310
88311   {
88312     try {
88313       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
88314     } catch (std::out_of_range& e) {
88315       {
88316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88317       };
88318     } catch (std::exception& e) {
88319       {
88320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88321       };
88322     } catch (...) {
88323       {
88324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88325       };
88326     }
88327   }
88328   jresult = (void *)result;
88329   return jresult;
88330 }
88331
88332
88333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
88334   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88335
88336   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88337   {
88338     try {
88339       delete arg1;
88340     } catch (std::out_of_range& e) {
88341       {
88342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88343       };
88344     } catch (std::exception& e) {
88345       {
88346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88347       };
88348     } catch (...) {
88349       {
88350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88351       };
88352     }
88353   }
88354 }
88355
88356
88357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
88358   unsigned int jresult ;
88359   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88360   bool result;
88361
88362   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88363   {
88364     try {
88365       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);
88366     } catch (std::out_of_range& e) {
88367       {
88368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88369       };
88370     } catch (std::exception& e) {
88371       {
88372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88373       };
88374     } catch (...) {
88375       {
88376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88377       };
88378     }
88379   }
88380   jresult = result;
88381   return jresult;
88382 }
88383
88384
88385 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
88386   unsigned long jresult ;
88387   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88388   std::size_t result;
88389
88390   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88391   {
88392     try {
88393       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);
88394     } catch (std::out_of_range& e) {
88395       {
88396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88397       };
88398     } catch (std::exception& e) {
88399       {
88400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88401       };
88402     } catch (...) {
88403       {
88404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88405       };
88406     }
88407   }
88408   jresult = (unsigned long)result;
88409   return jresult;
88410 }
88411
88412
88413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
88414   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88415   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88416
88417   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88418   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88419   {
88420     try {
88421       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
88422     } catch (std::out_of_range& e) {
88423       {
88424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88425       };
88426     } catch (std::exception& e) {
88427       {
88428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88429       };
88430     } catch (...) {
88431       {
88432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88433       };
88434     }
88435   }
88436 }
88437
88438
88439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88440   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88441   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88442
88443   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88444   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88445   {
88446     try {
88447       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
88448     } catch (std::out_of_range& e) {
88449       {
88450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88451       };
88452     } catch (std::exception& e) {
88453       {
88454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88455       };
88456     } catch (...) {
88457       {
88458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88459       };
88460     }
88461   }
88462 }
88463
88464
88465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88466   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88467   Dali::Toolkit::StyleManager arg2 ;
88468   Dali::StyleChange::Type arg3 ;
88469   Dali::Toolkit::StyleManager *argp2 ;
88470
88471   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88472   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
88473   if (!argp2) {
88474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
88475     return ;
88476   }
88477   arg2 = *argp2;
88478   arg3 = (Dali::StyleChange::Type)jarg3;
88479   {
88480     try {
88481       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
88482     } catch (std::out_of_range& e) {
88483       {
88484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88485       };
88486     } catch (std::exception& e) {
88487       {
88488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88489       };
88490     } catch (...) {
88491       {
88492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88493       };
88494     }
88495   }
88496 }
88497
88498
88499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
88500   void * jresult ;
88501   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
88502
88503   {
88504     try {
88505       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
88506     } catch (std::out_of_range& e) {
88507       {
88508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88509       };
88510     } catch (std::exception& e) {
88511       {
88512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88513       };
88514     } catch (...) {
88515       {
88516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88517       };
88518     }
88519   }
88520   jresult = (void *)result;
88521   return jresult;
88522 }
88523
88524
88525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
88526   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88527
88528   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88529   {
88530     try {
88531       delete arg1;
88532     } catch (std::out_of_range& e) {
88533       {
88534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88535       };
88536     } catch (std::exception& e) {
88537       {
88538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88539       };
88540     } catch (...) {
88541       {
88542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88543       };
88544     }
88545   }
88546 }
88547
88548
88549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
88550   unsigned int jresult ;
88551   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88552   bool result;
88553
88554   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88555   {
88556     try {
88557       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
88558     } catch (std::out_of_range& e) {
88559       {
88560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88561       };
88562     } catch (std::exception& e) {
88563       {
88564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88565       };
88566     } catch (...) {
88567       {
88568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88569       };
88570     }
88571   }
88572   jresult = result;
88573   return jresult;
88574 }
88575
88576
88577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
88578   unsigned long jresult ;
88579   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88580   std::size_t result;
88581
88582   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88583   {
88584     try {
88585       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
88586     } catch (std::out_of_range& e) {
88587       {
88588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88589       };
88590     } catch (std::exception& e) {
88591       {
88592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88593       };
88594     } catch (...) {
88595       {
88596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88597       };
88598     }
88599   }
88600   jresult = (unsigned long)result;
88601   return jresult;
88602 }
88603
88604
88605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
88606   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88607   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
88608
88609   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88610   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
88611   {
88612     try {
88613       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
88614     } catch (std::out_of_range& e) {
88615       {
88616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88617       };
88618     } catch (std::exception& e) {
88619       {
88620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88621       };
88622     } catch (...) {
88623       {
88624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88625       };
88626     }
88627   }
88628 }
88629
88630
88631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
88632   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88633   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
88634
88635   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88636   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
88637   {
88638     try {
88639       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
88640     } catch (std::out_of_range& e) {
88641       {
88642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88643       };
88644     } catch (std::exception& e) {
88645       {
88646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88647       };
88648     } catch (...) {
88649       {
88650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88651       };
88652     }
88653   }
88654 }
88655
88656
88657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
88658   unsigned int jresult ;
88659   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88660   Dali::Toolkit::Button arg2 ;
88661   Dali::Toolkit::Button *argp2 ;
88662   bool result;
88663
88664   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88665   argp2 = (Dali::Toolkit::Button *)jarg2;
88666   if (!argp2) {
88667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
88668     return 0;
88669   }
88670   arg2 = *argp2;
88671   {
88672     try {
88673       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
88674     } catch (std::out_of_range& e) {
88675       {
88676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88677       };
88678     } catch (std::exception& e) {
88679       {
88680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88681       };
88682     } catch (...) {
88683       {
88684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88685       };
88686     }
88687   }
88688   jresult = result;
88689   return jresult;
88690 }
88691
88692
88693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
88694   void * jresult ;
88695   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
88696
88697   {
88698     try {
88699       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
88700     } catch (std::out_of_range& e) {
88701       {
88702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88703       };
88704     } catch (std::exception& e) {
88705       {
88706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88707       };
88708     } catch (...) {
88709       {
88710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88711       };
88712     }
88713   }
88714   jresult = (void *)result;
88715   return jresult;
88716 }
88717
88718
88719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
88720   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88721
88722   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88723   {
88724     try {
88725       delete arg1;
88726     } catch (std::out_of_range& e) {
88727       {
88728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88729       };
88730     } catch (std::exception& e) {
88731       {
88732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88733       };
88734     } catch (...) {
88735       {
88736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88737       };
88738     }
88739   }
88740 }
88741
88742
88743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
88744   unsigned int jresult ;
88745   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88746   bool result;
88747
88748   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88749   {
88750     try {
88751       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
88752     } catch (std::out_of_range& e) {
88753       {
88754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88755       };
88756     } catch (std::exception& e) {
88757       {
88758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88759       };
88760     } catch (...) {
88761       {
88762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88763       };
88764     }
88765   }
88766   jresult = result;
88767   return jresult;
88768 }
88769
88770
88771 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
88772   unsigned long jresult ;
88773   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88774   std::size_t result;
88775
88776   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88777   {
88778     try {
88779       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
88780     } catch (std::out_of_range& e) {
88781       {
88782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88783       };
88784     } catch (std::exception& e) {
88785       {
88786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88787       };
88788     } catch (...) {
88789       {
88790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88791       };
88792     }
88793   }
88794   jresult = (unsigned long)result;
88795   return jresult;
88796 }
88797
88798
88799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
88800   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88801   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
88802
88803   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88804   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
88805   {
88806     try {
88807       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
88808     } catch (std::out_of_range& e) {
88809       {
88810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88811       };
88812     } catch (std::exception& e) {
88813       {
88814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88815       };
88816     } catch (...) {
88817       {
88818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88819       };
88820     }
88821   }
88822 }
88823
88824
88825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
88826   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88827   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
88828
88829   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88830   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
88831   {
88832     try {
88833       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
88834     } catch (std::out_of_range& e) {
88835       {
88836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88837       };
88838     } catch (std::exception& e) {
88839       {
88840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88841       };
88842     } catch (...) {
88843       {
88844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88845       };
88846     }
88847   }
88848 }
88849
88850
88851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
88852   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88853   Dali::Toolkit::GaussianBlurView arg2 ;
88854   Dali::Toolkit::GaussianBlurView *argp2 ;
88855
88856   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88857   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88858   if (!argp2) {
88859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
88860     return ;
88861   }
88862   arg2 = *argp2;
88863   {
88864     try {
88865       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
88866     } catch (std::out_of_range& e) {
88867       {
88868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88869       };
88870     } catch (std::exception& e) {
88871       {
88872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88873       };
88874     } catch (...) {
88875       {
88876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88877       };
88878     }
88879   }
88880 }
88881
88882
88883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
88884   void * jresult ;
88885   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
88886
88887   {
88888     try {
88889       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
88890     } catch (std::out_of_range& e) {
88891       {
88892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88893       };
88894     } catch (std::exception& e) {
88895       {
88896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88897       };
88898     } catch (...) {
88899       {
88900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88901       };
88902     }
88903   }
88904   jresult = (void *)result;
88905   return jresult;
88906 }
88907
88908
88909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
88910   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88911
88912   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88913   {
88914     try {
88915       delete arg1;
88916     } catch (std::out_of_range& e) {
88917       {
88918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88919       };
88920     } catch (std::exception& e) {
88921       {
88922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88923       };
88924     } catch (...) {
88925       {
88926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88927       };
88928     }
88929   }
88930 }
88931
88932
88933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
88934   unsigned int jresult ;
88935   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
88936   bool result;
88937
88938   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
88939   {
88940     try {
88941       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);
88942     } catch (std::out_of_range& e) {
88943       {
88944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88945       };
88946     } catch (std::exception& e) {
88947       {
88948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88949       };
88950     } catch (...) {
88951       {
88952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88953       };
88954     }
88955   }
88956   jresult = result;
88957   return jresult;
88958 }
88959
88960
88961 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
88962   unsigned long jresult ;
88963   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
88964   std::size_t result;
88965
88966   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
88967   {
88968     try {
88969       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);
88970     } catch (std::out_of_range& e) {
88971       {
88972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88973       };
88974     } catch (std::exception& e) {
88975       {
88976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88977       };
88978     } catch (...) {
88979       {
88980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88981       };
88982     }
88983   }
88984   jresult = (unsigned long)result;
88985   return jresult;
88986 }
88987
88988
88989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
88990   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
88991   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
88992
88993   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
88994   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
88995   {
88996     try {
88997       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
88998     } catch (std::out_of_range& e) {
88999       {
89000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89001       };
89002     } catch (std::exception& e) {
89003       {
89004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89005       };
89006     } catch (...) {
89007       {
89008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89009       };
89010     }
89011   }
89012 }
89013
89014
89015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89016   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89017   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89018
89019   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89020   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89021   {
89022     try {
89023       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89024     } catch (std::out_of_range& e) {
89025       {
89026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89027       };
89028     } catch (std::exception& e) {
89029       {
89030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89031       };
89032     } catch (...) {
89033       {
89034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89035       };
89036     }
89037   }
89038 }
89039
89040
89041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89042   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89043   Dali::Toolkit::PageTurnView arg2 ;
89044   unsigned int arg3 ;
89045   bool arg4 ;
89046   Dali::Toolkit::PageTurnView *argp2 ;
89047
89048   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89049   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89050   if (!argp2) {
89051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89052     return ;
89053   }
89054   arg2 = *argp2;
89055   arg3 = (unsigned int)jarg3;
89056   arg4 = jarg4 ? true : false;
89057   {
89058     try {
89059       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89060     } catch (std::out_of_range& e) {
89061       {
89062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89063       };
89064     } catch (std::exception& e) {
89065       {
89066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89067       };
89068     } catch (...) {
89069       {
89070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89071       };
89072     }
89073   }
89074 }
89075
89076
89077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89078   void * jresult ;
89079   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89080
89081   {
89082     try {
89083       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89084     } catch (std::out_of_range& e) {
89085       {
89086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89087       };
89088     } catch (std::exception& e) {
89089       {
89090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89091       };
89092     } catch (...) {
89093       {
89094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89095       };
89096     }
89097   }
89098   jresult = (void *)result;
89099   return jresult;
89100 }
89101
89102
89103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89104   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89105
89106   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89107   {
89108     try {
89109       delete arg1;
89110     } catch (std::out_of_range& e) {
89111       {
89112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89113       };
89114     } catch (std::exception& e) {
89115       {
89116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89117       };
89118     } catch (...) {
89119       {
89120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89121       };
89122     }
89123   }
89124 }
89125
89126
89127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89128   unsigned int jresult ;
89129   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89130   bool result;
89131
89132   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89133   {
89134     try {
89135       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89136     } catch (std::out_of_range& e) {
89137       {
89138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89139       };
89140     } catch (std::exception& e) {
89141       {
89142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89143       };
89144     } catch (...) {
89145       {
89146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89147       };
89148     }
89149   }
89150   jresult = result;
89151   return jresult;
89152 }
89153
89154
89155 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89156   unsigned long jresult ;
89157   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89158   std::size_t result;
89159
89160   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89161   {
89162     try {
89163       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89164     } catch (std::out_of_range& e) {
89165       {
89166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89167       };
89168     } catch (std::exception& e) {
89169       {
89170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89171       };
89172     } catch (...) {
89173       {
89174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89175       };
89176     }
89177   }
89178   jresult = (unsigned long)result;
89179   return jresult;
89180 }
89181
89182
89183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89184   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89185   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89186
89187   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89188   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89189   {
89190     try {
89191       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
89192     } catch (std::out_of_range& e) {
89193       {
89194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89195       };
89196     } catch (std::exception& e) {
89197       {
89198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89199       };
89200     } catch (...) {
89201       {
89202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89203       };
89204     }
89205   }
89206 }
89207
89208
89209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89210   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89211   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89212
89213   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89214   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89215   {
89216     try {
89217       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89218     } catch (std::out_of_range& e) {
89219       {
89220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89221       };
89222     } catch (std::exception& e) {
89223       {
89224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89225       };
89226     } catch (...) {
89227       {
89228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89229       };
89230     }
89231   }
89232 }
89233
89234
89235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89236   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89237   Dali::Toolkit::PageTurnView arg2 ;
89238   Dali::Toolkit::PageTurnView *argp2 ;
89239
89240   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89241   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89242   if (!argp2) {
89243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89244     return ;
89245   }
89246   arg2 = *argp2;
89247   {
89248     try {
89249       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89250     } catch (std::out_of_range& e) {
89251       {
89252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89253       };
89254     } catch (std::exception& e) {
89255       {
89256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89257       };
89258     } catch (...) {
89259       {
89260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89261       };
89262     }
89263   }
89264 }
89265
89266
89267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
89268   void * jresult ;
89269   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
89270
89271   {
89272     try {
89273       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
89274     } catch (std::out_of_range& e) {
89275       {
89276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89277       };
89278     } catch (std::exception& e) {
89279       {
89280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89281       };
89282     } catch (...) {
89283       {
89284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89285       };
89286     }
89287   }
89288   jresult = (void *)result;
89289   return jresult;
89290 }
89291
89292
89293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
89294   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89295
89296   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89297   {
89298     try {
89299       delete arg1;
89300     } catch (std::out_of_range& e) {
89301       {
89302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89303       };
89304     } catch (std::exception& e) {
89305       {
89306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89307       };
89308     } catch (...) {
89309       {
89310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89311       };
89312     }
89313   }
89314 }
89315
89316
89317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
89318   unsigned int jresult ;
89319   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89320   bool result;
89321
89322   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89323   {
89324     try {
89325       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);
89326     } catch (std::out_of_range& e) {
89327       {
89328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89329       };
89330     } catch (std::exception& e) {
89331       {
89332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89333       };
89334     } catch (...) {
89335       {
89336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89337       };
89338     }
89339   }
89340   jresult = result;
89341   return jresult;
89342 }
89343
89344
89345 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
89346   unsigned long jresult ;
89347   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89348   std::size_t result;
89349
89350   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89351   {
89352     try {
89353       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);
89354     } catch (std::out_of_range& e) {
89355       {
89356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89357       };
89358     } catch (std::exception& e) {
89359       {
89360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89361       };
89362     } catch (...) {
89363       {
89364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89365       };
89366     }
89367   }
89368   jresult = (unsigned long)result;
89369   return jresult;
89370 }
89371
89372
89373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
89374   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89375   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
89376
89377   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89378   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
89379   {
89380     try {
89381       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
89382     } catch (std::out_of_range& e) {
89383       {
89384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89385       };
89386     } catch (std::exception& e) {
89387       {
89388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89389       };
89390     } catch (...) {
89391       {
89392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89393       };
89394     }
89395   }
89396 }
89397
89398
89399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
89400   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89401   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
89402
89403   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89404   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
89405   {
89406     try {
89407       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
89408     } catch (std::out_of_range& e) {
89409       {
89410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89411       };
89412     } catch (std::exception& e) {
89413       {
89414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89415       };
89416     } catch (...) {
89417       {
89418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89419       };
89420     }
89421   }
89422 }
89423
89424
89425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
89426   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89427   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
89428
89429   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89430   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
89431   if (!arg2) {
89432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
89433     return ;
89434   }
89435   {
89436     try {
89437       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
89438     } catch (std::out_of_range& e) {
89439       {
89440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89441       };
89442     } catch (std::exception& e) {
89443       {
89444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89445       };
89446     } catch (...) {
89447       {
89448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89449       };
89450     }
89451   }
89452 }
89453
89454
89455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
89456   void * jresult ;
89457   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
89458
89459   {
89460     try {
89461       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
89462     } catch (std::out_of_range& e) {
89463       {
89464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89465       };
89466     } catch (std::exception& e) {
89467       {
89468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89469       };
89470     } catch (...) {
89471       {
89472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89473       };
89474     }
89475   }
89476   jresult = (void *)result;
89477   return jresult;
89478 }
89479
89480
89481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
89482   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89483
89484   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89485   {
89486     try {
89487       delete arg1;
89488     } catch (std::out_of_range& e) {
89489       {
89490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89491       };
89492     } catch (std::exception& e) {
89493       {
89494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89495       };
89496     } catch (...) {
89497       {
89498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89499       };
89500     }
89501   }
89502 }
89503
89504
89505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
89506   unsigned int jresult ;
89507   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89508   bool result;
89509
89510   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89511   {
89512     try {
89513       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
89514     } catch (std::out_of_range& e) {
89515       {
89516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89517       };
89518     } catch (std::exception& e) {
89519       {
89520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89521       };
89522     } catch (...) {
89523       {
89524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89525       };
89526     }
89527   }
89528   jresult = result;
89529   return jresult;
89530 }
89531
89532
89533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
89534   unsigned long jresult ;
89535   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89536   std::size_t result;
89537
89538   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89539   {
89540     try {
89541       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
89542     } catch (std::out_of_range& e) {
89543       {
89544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89545       };
89546     } catch (std::exception& e) {
89547       {
89548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89549       };
89550     } catch (...) {
89551       {
89552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89553       };
89554     }
89555   }
89556   jresult = (unsigned long)result;
89557   return jresult;
89558 }
89559
89560
89561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
89562   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89563   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
89564
89565   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89566   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
89567   {
89568     try {
89569       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
89570     } catch (std::out_of_range& e) {
89571       {
89572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89573       };
89574     } catch (std::exception& e) {
89575       {
89576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89577       };
89578     } catch (...) {
89579       {
89580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89581       };
89582     }
89583   }
89584 }
89585
89586
89587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
89588   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89589   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
89590
89591   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89592   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
89593   {
89594     try {
89595       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
89596     } catch (std::out_of_range& e) {
89597       {
89598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89599       };
89600     } catch (std::exception& e) {
89601       {
89602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89603       };
89604     } catch (...) {
89605       {
89606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89607       };
89608     }
89609   }
89610 }
89611
89612
89613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
89614   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89615   Dali::Vector2 *arg2 = 0 ;
89616
89617   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89618   arg2 = (Dali::Vector2 *)jarg2;
89619   if (!arg2) {
89620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89621     return ;
89622   }
89623   {
89624     try {
89625       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
89626     } catch (std::out_of_range& e) {
89627       {
89628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89629       };
89630     } catch (std::exception& e) {
89631       {
89632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89633       };
89634     } catch (...) {
89635       {
89636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89637       };
89638     }
89639   }
89640 }
89641
89642
89643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
89644   void * jresult ;
89645   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
89646
89647   {
89648     try {
89649       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
89650     } catch (std::out_of_range& e) {
89651       {
89652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89653       };
89654     } catch (std::exception& e) {
89655       {
89656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89657       };
89658     } catch (...) {
89659       {
89660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89661       };
89662     }
89663   }
89664   jresult = (void *)result;
89665   return jresult;
89666 }
89667
89668
89669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
89670   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89671
89672   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89673   {
89674     try {
89675       delete arg1;
89676     } catch (std::out_of_range& e) {
89677       {
89678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89679       };
89680     } catch (std::exception& e) {
89681       {
89682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89683       };
89684     } catch (...) {
89685       {
89686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89687       };
89688     }
89689   }
89690 }
89691
89692
89693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
89694   unsigned int jresult ;
89695   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89696   bool result;
89697
89698   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89699   {
89700     try {
89701       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
89702     } catch (std::out_of_range& e) {
89703       {
89704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89705       };
89706     } catch (std::exception& e) {
89707       {
89708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89709       };
89710     } catch (...) {
89711       {
89712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89713       };
89714     }
89715   }
89716   jresult = result;
89717   return jresult;
89718 }
89719
89720
89721 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
89722   unsigned long jresult ;
89723   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89724   std::size_t result;
89725
89726   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89727   {
89728     try {
89729       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
89730     } catch (std::out_of_range& e) {
89731       {
89732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89733       };
89734     } catch (std::exception& e) {
89735       {
89736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89737       };
89738     } catch (...) {
89739       {
89740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89741       };
89742     }
89743   }
89744   jresult = (unsigned long)result;
89745   return jresult;
89746 }
89747
89748
89749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
89750   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89751   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
89752
89753   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89754   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
89755   {
89756     try {
89757       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
89758     } catch (std::out_of_range& e) {
89759       {
89760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89761       };
89762     } catch (std::exception& e) {
89763       {
89764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89765       };
89766     } catch (...) {
89767       {
89768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89769       };
89770     }
89771   }
89772 }
89773
89774
89775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
89776   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89777   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
89778
89779   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89780   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
89781   {
89782     try {
89783       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
89784     } catch (std::out_of_range& e) {
89785       {
89786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89787       };
89788     } catch (std::exception& e) {
89789       {
89790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89791       };
89792     } catch (...) {
89793       {
89794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89795       };
89796     }
89797   }
89798 }
89799
89800
89801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
89802   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89803   Dali::Toolkit::TextEditor arg2 ;
89804   Dali::Toolkit::TextEditor *argp2 ;
89805
89806   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89807   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
89808   if (!argp2) {
89809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
89810     return ;
89811   }
89812   arg2 = *argp2;
89813   {
89814     try {
89815       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
89816     } catch (std::out_of_range& e) {
89817       {
89818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89819       };
89820     } catch (std::exception& e) {
89821       {
89822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89823       };
89824     } catch (...) {
89825       {
89826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89827       };
89828     }
89829   }
89830 }
89831
89832
89833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
89834   void * jresult ;
89835   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
89836
89837   {
89838     try {
89839       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
89840     } catch (std::out_of_range& e) {
89841       {
89842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89843       };
89844     } catch (std::exception& e) {
89845       {
89846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89847       };
89848     } catch (...) {
89849       {
89850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89851       };
89852     }
89853   }
89854   jresult = (void *)result;
89855   return jresult;
89856 }
89857
89858
89859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
89860   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89861
89862   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89863   {
89864     try {
89865       delete arg1;
89866     } catch (std::out_of_range& e) {
89867       {
89868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89869       };
89870     } catch (std::exception& e) {
89871       {
89872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89873       };
89874     } catch (...) {
89875       {
89876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89877       };
89878     }
89879   }
89880 }
89881
89882
89883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
89884   unsigned int jresult ;
89885   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
89886   bool result;
89887
89888   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
89889   {
89890     try {
89891       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
89892     } catch (std::out_of_range& e) {
89893       {
89894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89895       };
89896     } catch (std::exception& e) {
89897       {
89898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89899       };
89900     } catch (...) {
89901       {
89902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89903       };
89904     }
89905   }
89906   jresult = result;
89907   return jresult;
89908 }
89909
89910
89911 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
89912   unsigned long jresult ;
89913   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
89914   std::size_t result;
89915
89916   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
89917   {
89918     try {
89919       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
89920     } catch (std::out_of_range& e) {
89921       {
89922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89923       };
89924     } catch (std::exception& e) {
89925       {
89926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89927       };
89928     } catch (...) {
89929       {
89930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89931       };
89932     }
89933   }
89934   jresult = (unsigned long)result;
89935   return jresult;
89936 }
89937
89938
89939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
89940   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
89941   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
89942
89943   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
89944   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
89945   {
89946     try {
89947       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
89948     } catch (std::out_of_range& e) {
89949       {
89950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89951       };
89952     } catch (std::exception& e) {
89953       {
89954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89955       };
89956     } catch (...) {
89957       {
89958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89959       };
89960     }
89961   }
89962 }
89963
89964
89965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
89966   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
89967   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
89968
89969   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
89970   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
89971   {
89972     try {
89973       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
89974     } catch (std::out_of_range& e) {
89975       {
89976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89977       };
89978     } catch (std::exception& e) {
89979       {
89980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89981       };
89982     } catch (...) {
89983       {
89984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89985       };
89986     }
89987   }
89988 }
89989
89990
89991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
89992   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
89993   Dali::Toolkit::TextField arg2 ;
89994   Dali::Toolkit::TextField *argp2 ;
89995
89996   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
89997   argp2 = (Dali::Toolkit::TextField *)jarg2;
89998   if (!argp2) {
89999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90000     return ;
90001   }
90002   arg2 = *argp2;
90003   {
90004     try {
90005       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90006     } catch (std::out_of_range& e) {
90007       {
90008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90009       };
90010     } catch (std::exception& e) {
90011       {
90012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90013       };
90014     } catch (...) {
90015       {
90016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90017       };
90018     }
90019   }
90020 }
90021
90022
90023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90024   void * jresult ;
90025   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90026
90027   {
90028     try {
90029       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90030     } catch (std::out_of_range& e) {
90031       {
90032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90033       };
90034     } catch (std::exception& e) {
90035       {
90036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90037       };
90038     } catch (...) {
90039       {
90040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90041       };
90042     }
90043   }
90044   jresult = (void *)result;
90045   return jresult;
90046 }
90047
90048
90049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90050   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90051
90052   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90053   {
90054     try {
90055       delete arg1;
90056     } catch (std::out_of_range& e) {
90057       {
90058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90059       };
90060     } catch (std::exception& e) {
90061       {
90062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90063       };
90064     } catch (...) {
90065       {
90066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90067       };
90068     }
90069   }
90070 }
90071
90072
90073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
90074   unsigned int jresult ;
90075   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90076   bool result;
90077
90078   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90079   {
90080     try {
90081       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);
90082     } catch (std::out_of_range& e) {
90083       {
90084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90085       };
90086     } catch (std::exception& e) {
90087       {
90088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90089       };
90090     } catch (...) {
90091       {
90092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90093       };
90094     }
90095   }
90096   jresult = result;
90097   return jresult;
90098 }
90099
90100
90101 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
90102   unsigned long jresult ;
90103   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90104   std::size_t result;
90105
90106   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90107   {
90108     try {
90109       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);
90110     } catch (std::out_of_range& e) {
90111       {
90112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90113       };
90114     } catch (std::exception& e) {
90115       {
90116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90117       };
90118     } catch (...) {
90119       {
90120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90121       };
90122     }
90123   }
90124   jresult = (unsigned long)result;
90125   return jresult;
90126 }
90127
90128
90129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
90130   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90131   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90132
90133   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90134   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90135   {
90136     try {
90137       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90138     } catch (std::out_of_range& e) {
90139       {
90140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90141       };
90142     } catch (std::exception& e) {
90143       {
90144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90145       };
90146     } catch (...) {
90147       {
90148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90149       };
90150     }
90151   }
90152 }
90153
90154
90155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
90156   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90157   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90158
90159   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90160   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90161   {
90162     try {
90163       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90164     } catch (std::out_of_range& e) {
90165       {
90166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90167       };
90168     } catch (std::exception& e) {
90169       {
90170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90171       };
90172     } catch (...) {
90173       {
90174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90175       };
90176     }
90177   }
90178 }
90179
90180
90181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90182   unsigned int jresult ;
90183   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90184   Dali::Toolkit::Control arg2 ;
90185   Dali::KeyEvent *arg3 = 0 ;
90186   Dali::Toolkit::Control *argp2 ;
90187   bool result;
90188
90189   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90190   argp2 = (Dali::Toolkit::Control *)jarg2;
90191   if (!argp2) {
90192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90193     return 0;
90194   }
90195   arg2 = *argp2;
90196   arg3 = (Dali::KeyEvent *)jarg3;
90197   if (!arg3) {
90198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
90199     return 0;
90200   }
90201   {
90202     try {
90203       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);
90204     } catch (std::out_of_range& e) {
90205       {
90206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90207       };
90208     } catch (std::exception& e) {
90209       {
90210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90211       };
90212     } catch (...) {
90213       {
90214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90215       };
90216     }
90217   }
90218   jresult = result;
90219   return jresult;
90220 }
90221
90222
90223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
90224   void * jresult ;
90225   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
90226
90227   {
90228     try {
90229       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
90230     } catch (std::out_of_range& e) {
90231       {
90232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90233       };
90234     } catch (std::exception& e) {
90235       {
90236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90237       };
90238     } catch (...) {
90239       {
90240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90241       };
90242     }
90243   }
90244   jresult = (void *)result;
90245   return jresult;
90246 }
90247
90248
90249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
90250   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90251
90252   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90253   {
90254     try {
90255       delete arg1;
90256     } catch (std::out_of_range& e) {
90257       {
90258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90259       };
90260     } catch (std::exception& e) {
90261       {
90262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90263       };
90264     } catch (...) {
90265       {
90266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90267       };
90268     }
90269   }
90270 }
90271
90272
90273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
90274   unsigned int jresult ;
90275   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90276   bool result;
90277
90278   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90279   {
90280     try {
90281       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
90282     } catch (std::out_of_range& e) {
90283       {
90284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90285       };
90286     } catch (std::exception& e) {
90287       {
90288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90289       };
90290     } catch (...) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90293       };
90294     }
90295   }
90296   jresult = result;
90297   return jresult;
90298 }
90299
90300
90301 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
90302   unsigned long jresult ;
90303   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90304   std::size_t result;
90305
90306   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90307   {
90308     try {
90309       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
90310     } catch (std::out_of_range& e) {
90311       {
90312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90313       };
90314     } catch (std::exception& e) {
90315       {
90316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90317       };
90318     } catch (...) {
90319       {
90320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90321       };
90322     }
90323   }
90324   jresult = (unsigned long)result;
90325   return jresult;
90326 }
90327
90328
90329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
90330   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90331   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
90332
90333   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90334   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
90335   {
90336     try {
90337       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
90338     } catch (std::out_of_range& e) {
90339       {
90340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90341       };
90342     } catch (std::exception& e) {
90343       {
90344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90345       };
90346     } catch (...) {
90347       {
90348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90349       };
90350     }
90351   }
90352 }
90353
90354
90355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
90356   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90357   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
90358
90359   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90360   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
90361   {
90362     try {
90363       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
90364     } catch (std::out_of_range& e) {
90365       {
90366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90367       };
90368     } catch (std::exception& e) {
90369       {
90370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90371       };
90372     } catch (...) {
90373       {
90374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90375       };
90376     }
90377   }
90378 }
90379
90380
90381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
90382   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90383   Dali::Toolkit::Control arg2 ;
90384   Dali::Toolkit::Control *argp2 ;
90385
90386   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90387   argp2 = (Dali::Toolkit::Control *)jarg2;
90388   if (!argp2) {
90389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90390     return ;
90391   }
90392   arg2 = *argp2;
90393   {
90394     try {
90395       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
90396     } catch (std::out_of_range& e) {
90397       {
90398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90399       };
90400     } catch (std::exception& e) {
90401       {
90402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90403       };
90404     } catch (...) {
90405       {
90406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90407       };
90408     }
90409   }
90410 }
90411
90412
90413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
90414   void * jresult ;
90415   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
90416
90417   {
90418     try {
90419       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
90420     } catch (std::out_of_range& e) {
90421       {
90422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90423       };
90424     } catch (std::exception& e) {
90425       {
90426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90427       };
90428     } catch (...) {
90429       {
90430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90431       };
90432     }
90433   }
90434   jresult = (void *)result;
90435   return jresult;
90436 }
90437
90438
90439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
90440   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90441
90442   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90443   {
90444     try {
90445       delete arg1;
90446     } catch (std::out_of_range& e) {
90447       {
90448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90449       };
90450     } catch (std::exception& e) {
90451       {
90452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90453       };
90454     } catch (...) {
90455       {
90456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90457       };
90458     }
90459   }
90460 }
90461
90462
90463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
90464   unsigned int jresult ;
90465   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90466   bool result;
90467
90468   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90469   {
90470     try {
90471       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
90472     } catch (std::out_of_range& e) {
90473       {
90474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90475       };
90476     } catch (std::exception& e) {
90477       {
90478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90479       };
90480     } catch (...) {
90481       {
90482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90483       };
90484     }
90485   }
90486   jresult = result;
90487   return jresult;
90488 }
90489
90490
90491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
90492   unsigned long jresult ;
90493   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90494   std::size_t result;
90495
90496   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90497   {
90498     try {
90499       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
90500     } catch (std::out_of_range& e) {
90501       {
90502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90503       };
90504     } catch (std::exception& e) {
90505       {
90506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90507       };
90508     } catch (...) {
90509       {
90510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90511       };
90512     }
90513   }
90514   jresult = (unsigned long)result;
90515   return jresult;
90516 }
90517
90518
90519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
90520   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90521   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
90522
90523   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90524   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
90525   {
90526     try {
90527       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
90528     } catch (std::out_of_range& e) {
90529       {
90530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90531       };
90532     } catch (std::exception& e) {
90533       {
90534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90535       };
90536     } catch (...) {
90537       {
90538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90539       };
90540     }
90541   }
90542 }
90543
90544
90545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
90546   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90547   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
90548
90549   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90550   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
90551   {
90552     try {
90553       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
90554     } catch (std::out_of_range& e) {
90555       {
90556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90557       };
90558     } catch (std::exception& e) {
90559       {
90560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90561       };
90562     } catch (...) {
90563       {
90564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90565       };
90566     }
90567   }
90568 }
90569
90570
90571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
90572   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90573   Dali::Toolkit::VideoView *arg2 = 0 ;
90574
90575   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90576   arg2 = (Dali::Toolkit::VideoView *)jarg2;
90577   if (!arg2) {
90578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
90579     return ;
90580   }
90581   {
90582     try {
90583       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
90584     } catch (std::out_of_range& e) {
90585       {
90586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90587       };
90588     } catch (std::exception& e) {
90589       {
90590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90591       };
90592     } catch (...) {
90593       {
90594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90595       };
90596     }
90597   }
90598 }
90599
90600
90601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
90602   void * jresult ;
90603   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
90604
90605   {
90606     try {
90607       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
90608     } catch (std::out_of_range& e) {
90609       {
90610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90611       };
90612     } catch (std::exception& e) {
90613       {
90614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90615       };
90616     } catch (...) {
90617       {
90618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90619       };
90620     }
90621   }
90622   jresult = (void *)result;
90623   return jresult;
90624 }
90625
90626
90627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
90628   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90629
90630   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90631   {
90632     try {
90633       delete arg1;
90634     } catch (std::out_of_range& e) {
90635       {
90636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90637       };
90638     } catch (std::exception& e) {
90639       {
90640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90641       };
90642     } catch (...) {
90643       {
90644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90645       };
90646     }
90647   }
90648 }
90649
90650
90651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
90652   unsigned int jresult ;
90653   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90654   bool result;
90655
90656   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90657   {
90658     try {
90659       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
90660     } catch (std::out_of_range& e) {
90661       {
90662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90663       };
90664     } catch (std::exception& e) {
90665       {
90666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90667       };
90668     } catch (...) {
90669       {
90670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90671       };
90672     }
90673   }
90674   jresult = result;
90675   return jresult;
90676 }
90677
90678
90679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
90680   unsigned long jresult ;
90681   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90682   std::size_t result;
90683
90684   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90685   {
90686     try {
90687       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
90688     } catch (std::out_of_range& e) {
90689       {
90690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90691       };
90692     } catch (std::exception& e) {
90693       {
90694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90695       };
90696     } catch (...) {
90697       {
90698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90699       };
90700     }
90701   }
90702   jresult = (unsigned long)result;
90703   return jresult;
90704 }
90705
90706
90707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
90708   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90709   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
90710
90711   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90712   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
90713   {
90714     try {
90715       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
90716     } catch (std::out_of_range& e) {
90717       {
90718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90719       };
90720     } catch (std::exception& e) {
90721       {
90722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90723       };
90724     } catch (...) {
90725       {
90726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90727       };
90728     }
90729   }
90730 }
90731
90732
90733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90734   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90735   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
90736
90737   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90738   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
90739   {
90740     try {
90741       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
90742     } catch (std::out_of_range& e) {
90743       {
90744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90745       };
90746     } catch (std::exception& e) {
90747       {
90748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90749       };
90750     } catch (...) {
90751       {
90752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90753       };
90754     }
90755   }
90756 }
90757
90758
90759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
90760   unsigned int jresult ;
90761   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90762   Dali::Toolkit::Slider arg2 ;
90763   float arg3 ;
90764   Dali::Toolkit::Slider *argp2 ;
90765   bool result;
90766
90767   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90768   argp2 = (Dali::Toolkit::Slider *)jarg2;
90769   if (!argp2) {
90770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
90771     return 0;
90772   }
90773   arg2 = *argp2;
90774   arg3 = (float)jarg3;
90775   {
90776     try {
90777       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
90778     } catch (std::out_of_range& e) {
90779       {
90780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90781       };
90782     } catch (std::exception& e) {
90783       {
90784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90785       };
90786     } catch (...) {
90787       {
90788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90789       };
90790     }
90791   }
90792   jresult = result;
90793   return jresult;
90794 }
90795
90796
90797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
90798   void * jresult ;
90799   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
90800
90801   {
90802     try {
90803       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
90804     } catch (std::out_of_range& e) {
90805       {
90806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90807       };
90808     } catch (std::exception& e) {
90809       {
90810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90811       };
90812     } catch (...) {
90813       {
90814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90815       };
90816     }
90817   }
90818   jresult = (void *)result;
90819   return jresult;
90820 }
90821
90822
90823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
90824   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90825
90826   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90827   {
90828     try {
90829       delete arg1;
90830     } catch (std::out_of_range& e) {
90831       {
90832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90833       };
90834     } catch (std::exception& e) {
90835       {
90836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90837       };
90838     } catch (...) {
90839       {
90840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90841       };
90842     }
90843   }
90844 }
90845
90846
90847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
90848   unsigned int jresult ;
90849   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
90850   bool result;
90851
90852   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
90853   {
90854     try {
90855       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
90856     } catch (std::out_of_range& e) {
90857       {
90858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90859       };
90860     } catch (std::exception& e) {
90861       {
90862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90863       };
90864     } catch (...) {
90865       {
90866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90867       };
90868     }
90869   }
90870   jresult = result;
90871   return jresult;
90872 }
90873
90874
90875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
90876   unsigned long jresult ;
90877   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
90878   std::size_t result;
90879
90880   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
90881   {
90882     try {
90883       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
90884     } catch (std::out_of_range& e) {
90885       {
90886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90887       };
90888     } catch (std::exception& e) {
90889       {
90890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90891       };
90892     } catch (...) {
90893       {
90894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90895       };
90896     }
90897   }
90898   jresult = (unsigned long)result;
90899   return jresult;
90900 }
90901
90902
90903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
90904   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
90905   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
90906
90907   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
90908   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
90909   {
90910     try {
90911       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
90912     } catch (std::out_of_range& e) {
90913       {
90914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90915       };
90916     } catch (std::exception& e) {
90917       {
90918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90919       };
90920     } catch (...) {
90921       {
90922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90923       };
90924     }
90925   }
90926 }
90927
90928
90929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
90930   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
90931   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
90932
90933   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
90934   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
90935   {
90936     try {
90937       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
90938     } catch (std::out_of_range& e) {
90939       {
90940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90941       };
90942     } catch (std::exception& e) {
90943       {
90944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90945       };
90946     } catch (...) {
90947       {
90948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90949       };
90950     }
90951   }
90952 }
90953
90954
90955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90956   unsigned int jresult ;
90957   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
90958   Dali::Toolkit::Slider arg2 ;
90959   int arg3 ;
90960   Dali::Toolkit::Slider *argp2 ;
90961   bool result;
90962
90963   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
90964   argp2 = (Dali::Toolkit::Slider *)jarg2;
90965   if (!argp2) {
90966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
90967     return 0;
90968   }
90969   arg2 = *argp2;
90970   arg3 = (int)jarg3;
90971   {
90972     try {
90973       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
90974     } catch (std::out_of_range& e) {
90975       {
90976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90977       };
90978     } catch (std::exception& e) {
90979       {
90980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90981       };
90982     } catch (...) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90985       };
90986     }
90987   }
90988   jresult = result;
90989   return jresult;
90990 }
90991
90992
90993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
90994   void * jresult ;
90995   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
90996
90997   {
90998     try {
90999       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91000     } catch (std::out_of_range& e) {
91001       {
91002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91003       };
91004     } catch (std::exception& e) {
91005       {
91006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91007       };
91008     } catch (...) {
91009       {
91010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91011       };
91012     }
91013   }
91014   jresult = (void *)result;
91015   return jresult;
91016 }
91017
91018
91019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91020   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91021
91022   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91023   {
91024     try {
91025       delete arg1;
91026     } catch (std::out_of_range& e) {
91027       {
91028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91029       };
91030     } catch (std::exception& e) {
91031       {
91032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91033       };
91034     } catch (...) {
91035       {
91036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91037       };
91038     }
91039   }
91040 }
91041
91042
91043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91044   void * jresult ;
91045   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91046
91047   {
91048     try {
91049       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91050     } catch (std::out_of_range& e) {
91051       {
91052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91053       };
91054     } catch (std::exception& e) {
91055       {
91056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91057       };
91058     } catch (...) {
91059       {
91060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91061       };
91062     }
91063   }
91064   jresult = (void *)result;
91065   return jresult;
91066 }
91067
91068
91069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
91070   void * jresult ;
91071   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
91072   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91073
91074   arg1 = (Dali::Toolkit::Ruler *)jarg1;
91075   {
91076     try {
91077       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
91078     } catch (std::out_of_range& e) {
91079       {
91080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91081       };
91082     } catch (std::exception& e) {
91083       {
91084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91085       };
91086     } catch (...) {
91087       {
91088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91089       };
91090     }
91091   }
91092   jresult = (void *)result;
91093   return jresult;
91094 }
91095
91096
91097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
91098   void * jresult ;
91099   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
91100   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91101
91102   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91103   if (!arg1) {
91104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91105     return 0;
91106   }
91107   {
91108     try {
91109       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
91110     } catch (std::out_of_range& e) {
91111       {
91112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91113       };
91114     } catch (std::exception& e) {
91115       {
91116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91117       };
91118     } catch (...) {
91119       {
91120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91121       };
91122     }
91123   }
91124   jresult = (void *)result;
91125   return jresult;
91126 }
91127
91128
91129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
91130   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91131
91132   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91133   {
91134     try {
91135       delete arg1;
91136     } catch (std::out_of_range& e) {
91137       {
91138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91139       };
91140     } catch (std::exception& e) {
91141       {
91142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91143       };
91144     } catch (...) {
91145       {
91146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91147       };
91148     }
91149   }
91150 }
91151
91152
91153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
91154   void * jresult ;
91155   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91156   Dali::Toolkit::Ruler *result = 0 ;
91157
91158   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91159   {
91160     try {
91161       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
91162     } catch (std::out_of_range& e) {
91163       {
91164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91165       };
91166     } catch (std::exception& e) {
91167       {
91168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91169       };
91170     } catch (...) {
91171       {
91172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91173       };
91174     }
91175   }
91176   jresult = (void *)result;
91177   return jresult;
91178 }
91179
91180
91181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
91182   void * jresult ;
91183   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91184   Dali::Toolkit::Ruler *result = 0 ;
91185
91186   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91187   {
91188     try {
91189       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
91190     } catch (std::out_of_range& e) {
91191       {
91192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91193       };
91194     } catch (std::exception& e) {
91195       {
91196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91197       };
91198     } catch (...) {
91199       {
91200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91201       };
91202     }
91203   }
91204   jresult = (void *)result;
91205   return jresult;
91206 }
91207
91208
91209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
91210   void * jresult ;
91211   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91212   Dali::Toolkit::Ruler *result = 0 ;
91213
91214   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91215   {
91216     try {
91217       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
91218     } catch (std::out_of_range& e) {
91219       {
91220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91221       };
91222     } catch (std::exception& e) {
91223       {
91224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91225       };
91226     } catch (...) {
91227       {
91228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91229       };
91230     }
91231   }
91232   jresult = (void *)result;
91233   return jresult;
91234 }
91235
91236
91237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
91238   void * jresult ;
91239   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91240   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
91241   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91242
91243   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91244   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
91245   if (!arg2) {
91246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91247     return 0;
91248   }
91249   {
91250     try {
91251       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
91252     } catch (std::out_of_range& e) {
91253       {
91254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91255       };
91256     } catch (std::exception& e) {
91257       {
91258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91259       };
91260     } catch (...) {
91261       {
91262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91263       };
91264     }
91265   }
91266   jresult = (void *)result;
91267   return jresult;
91268 }
91269
91270
91271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
91272   void * jresult ;
91273   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91274   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
91275   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91276
91277   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91278   arg2 = (Dali::Toolkit::Ruler *)jarg2;
91279   {
91280     try {
91281       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
91282     } catch (std::out_of_range& e) {
91283       {
91284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91285       };
91286     } catch (std::exception& e) {
91287       {
91288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91289       };
91290     } catch (...) {
91291       {
91292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91293       };
91294     }
91295   }
91296   jresult = (void *)result;
91297   return jresult;
91298 }
91299
91300
91301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
91302   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91303
91304   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91305   {
91306     try {
91307       (arg1)->Reset();
91308     } catch (std::out_of_range& e) {
91309       {
91310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91311       };
91312     } catch (std::exception& e) {
91313       {
91314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91315       };
91316     } catch (...) {
91317       {
91318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91319       };
91320     }
91321   }
91322 }
91323
91324
91325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
91326   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91327   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
91328
91329   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91330   arg2 = (Dali::Toolkit::Ruler *)jarg2;
91331   {
91332     try {
91333       (arg1)->Reset(arg2);
91334     } catch (std::out_of_range& e) {
91335       {
91336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91337       };
91338     } catch (std::exception& e) {
91339       {
91340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91341       };
91342     } catch (...) {
91343       {
91344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91345       };
91346     }
91347   }
91348 }
91349
91350
91351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
91352   void * jresult ;
91353   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91354   Dali::Toolkit::Ruler *result = 0 ;
91355
91356   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91357   {
91358     try {
91359       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
91360     } catch (std::out_of_range& e) {
91361       {
91362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91363       };
91364     } catch (std::exception& e) {
91365       {
91366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91367       };
91368     } catch (...) {
91369       {
91370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91371       };
91372     }
91373   }
91374   jresult = (void *)result;
91375   return jresult;
91376 }
91377
91378
91379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
91380   float jresult ;
91381   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91382   float arg2 ;
91383   float arg3 ;
91384   float result;
91385
91386   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91387   arg2 = (float)jarg2;
91388   arg3 = (float)jarg3;
91389   {
91390     try {
91391       result = (float)(*arg1)->Snap(arg2,arg3);
91392     } catch (std::out_of_range& e) {
91393       {
91394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91395       };
91396     } catch (std::exception& e) {
91397       {
91398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91399       };
91400     } catch (...) {
91401       {
91402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91403       };
91404     }
91405   }
91406   jresult = result;
91407   return jresult;
91408 }
91409
91410
91411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
91412   float jresult ;
91413   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91414   float arg2 ;
91415   float result;
91416
91417   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91418   arg2 = (float)jarg2;
91419   {
91420     try {
91421       result = (float)(*arg1)->Snap(arg2);
91422     } catch (std::out_of_range& e) {
91423       {
91424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91425       };
91426     } catch (std::exception& e) {
91427       {
91428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91429       };
91430     } catch (...) {
91431       {
91432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91433       };
91434     }
91435   }
91436   jresult = result;
91437   return jresult;
91438 }
91439
91440
91441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
91442   float jresult ;
91443   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91444   unsigned int arg2 ;
91445   unsigned int *arg3 = 0 ;
91446   bool arg4 ;
91447   float result;
91448
91449   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91450   arg2 = (unsigned int)jarg2;
91451   arg3 = (unsigned int *)jarg3;
91452   arg4 = jarg4 ? true : false;
91453   {
91454     try {
91455       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
91456     } catch (std::out_of_range& e) {
91457       {
91458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91459       };
91460     } catch (std::exception& e) {
91461       {
91462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91463       };
91464     } catch (...) {
91465       {
91466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91467       };
91468     }
91469   }
91470   jresult = result;
91471   return jresult;
91472 }
91473
91474
91475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
91476   unsigned int jresult ;
91477   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91478   float arg2 ;
91479   bool arg3 ;
91480   unsigned int result;
91481
91482   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91483   arg2 = (float)jarg2;
91484   arg3 = jarg3 ? true : false;
91485   {
91486     try {
91487       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
91488     } catch (std::out_of_range& e) {
91489       {
91490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91491       };
91492     } catch (std::exception& e) {
91493       {
91494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91495       };
91496     } catch (...) {
91497       {
91498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91499       };
91500     }
91501   }
91502   jresult = result;
91503   return jresult;
91504 }
91505
91506
91507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
91508   unsigned int jresult ;
91509   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91510   unsigned int result;
91511
91512   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91513   {
91514     try {
91515       result = (unsigned int)(*arg1)->GetTotalPages();
91516     } catch (std::out_of_range& e) {
91517       {
91518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91519       };
91520     } catch (std::exception& e) {
91521       {
91522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91523       };
91524     } catch (...) {
91525       {
91526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91527       };
91528     }
91529   }
91530   jresult = result;
91531   return jresult;
91532 }
91533
91534
91535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
91536   int jresult ;
91537   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91538   Dali::Toolkit::Ruler::RulerType result;
91539
91540   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91541   {
91542     try {
91543       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
91544     } catch (std::out_of_range& e) {
91545       {
91546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91547       };
91548     } catch (std::exception& e) {
91549       {
91550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91551       };
91552     } catch (...) {
91553       {
91554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91555       };
91556     }
91557   }
91558   jresult = (int)result;
91559   return jresult;
91560 }
91561
91562
91563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
91564   unsigned int jresult ;
91565   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91566   bool result;
91567
91568   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91569   {
91570     try {
91571       result = (bool)(*arg1)->IsEnabled();
91572     } catch (std::out_of_range& e) {
91573       {
91574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91575       };
91576     } catch (std::exception& e) {
91577       {
91578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91579       };
91580     } catch (...) {
91581       {
91582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91583       };
91584     }
91585   }
91586   jresult = result;
91587   return jresult;
91588 }
91589
91590
91591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
91592   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91593
91594   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91595   {
91596     try {
91597       (*arg1)->Enable();
91598     } catch (std::out_of_range& e) {
91599       {
91600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91601       };
91602     } catch (std::exception& e) {
91603       {
91604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91605       };
91606     } catch (...) {
91607       {
91608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91609       };
91610     }
91611   }
91612 }
91613
91614
91615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
91616   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91617
91618   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91619   {
91620     try {
91621       (*arg1)->Disable();
91622     } catch (std::out_of_range& e) {
91623       {
91624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91625       };
91626     } catch (std::exception& e) {
91627       {
91628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91629       };
91630     } catch (...) {
91631       {
91632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91633       };
91634     }
91635   }
91636 }
91637
91638
91639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
91640   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91641   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
91642   Dali::Toolkit::RulerDomain *argp2 ;
91643
91644   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91645   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
91646   if (!argp2) {
91647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
91648     return ;
91649   }
91650   arg2 = *argp2;
91651   {
91652     try {
91653       (*arg1)->SetDomain(arg2);
91654     } catch (std::out_of_range& e) {
91655       {
91656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91657       };
91658     } catch (std::exception& e) {
91659       {
91660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91661       };
91662     } catch (...) {
91663       {
91664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91665       };
91666     }
91667   }
91668 }
91669
91670
91671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
91672   void * jresult ;
91673   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91674   Dali::Toolkit::RulerDomain *result = 0 ;
91675
91676   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91677   {
91678     try {
91679       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
91680     } catch (std::out_of_range& e) {
91681       {
91682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91683       };
91684     } catch (std::exception& e) {
91685       {
91686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91687       };
91688     } catch (...) {
91689       {
91690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91691       };
91692     }
91693   }
91694   jresult = (void *)result;
91695   return jresult;
91696 }
91697
91698
91699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
91700   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91701
91702   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91703   {
91704     try {
91705       (*arg1)->DisableDomain();
91706     } catch (std::out_of_range& e) {
91707       {
91708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91709       };
91710     } catch (std::exception& e) {
91711       {
91712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91713       };
91714     } catch (...) {
91715       {
91716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91717       };
91718     }
91719   }
91720 }
91721
91722
91723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
91724   float jresult ;
91725   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91726   float arg2 ;
91727   float arg3 ;
91728   float arg4 ;
91729   float result;
91730
91731   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91732   arg2 = (float)jarg2;
91733   arg3 = (float)jarg3;
91734   arg4 = (float)jarg4;
91735   {
91736     try {
91737       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
91738     } catch (std::out_of_range& e) {
91739       {
91740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91741       };
91742     } catch (std::exception& e) {
91743       {
91744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91745       };
91746     } catch (...) {
91747       {
91748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91749       };
91750     }
91751   }
91752   jresult = result;
91753   return jresult;
91754 }
91755
91756
91757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
91758   float jresult ;
91759   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91760   float arg2 ;
91761   float arg3 ;
91762   float result;
91763
91764   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91765   arg2 = (float)jarg2;
91766   arg3 = (float)jarg3;
91767   {
91768     try {
91769       result = (float)(*arg1)->Clamp(arg2,arg3);
91770     } catch (std::out_of_range& e) {
91771       {
91772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91773       };
91774     } catch (std::exception& e) {
91775       {
91776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91777       };
91778     } catch (...) {
91779       {
91780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91781       };
91782     }
91783   }
91784   jresult = result;
91785   return jresult;
91786 }
91787
91788
91789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
91790   float jresult ;
91791   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91792   float arg2 ;
91793   float result;
91794
91795   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91796   arg2 = (float)jarg2;
91797   {
91798     try {
91799       result = (float)(*arg1)->Clamp(arg2);
91800     } catch (std::out_of_range& e) {
91801       {
91802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91803       };
91804     } catch (std::exception& e) {
91805       {
91806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91807       };
91808     } catch (...) {
91809       {
91810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91811       };
91812     }
91813   }
91814   jresult = result;
91815   return jresult;
91816 }
91817
91818
91819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
91820   float jresult ;
91821   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91822   float arg2 ;
91823   float arg3 ;
91824   float arg4 ;
91825   Dali::Toolkit::ClampState *arg5 = 0 ;
91826   float result;
91827
91828   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91829   arg2 = (float)jarg2;
91830   arg3 = (float)jarg3;
91831   arg4 = (float)jarg4;
91832   arg5 = (Dali::Toolkit::ClampState *)jarg5;
91833   if (!arg5) {
91834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
91835     return 0;
91836   }
91837   {
91838     try {
91839       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
91840     } catch (std::out_of_range& e) {
91841       {
91842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91843       };
91844     } catch (std::exception& e) {
91845       {
91846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91847       };
91848     } catch (...) {
91849       {
91850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91851       };
91852     }
91853   }
91854   jresult = result;
91855   return jresult;
91856 }
91857
91858
91859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
91860   float jresult ;
91861   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91862   float arg2 ;
91863   float arg3 ;
91864   float arg4 ;
91865   float arg5 ;
91866   float result;
91867
91868   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91869   arg2 = (float)jarg2;
91870   arg3 = (float)jarg3;
91871   arg4 = (float)jarg4;
91872   arg5 = (float)jarg5;
91873   {
91874     try {
91875       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
91876     } catch (std::out_of_range& e) {
91877       {
91878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91879       };
91880     } catch (std::exception& e) {
91881       {
91882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91883       };
91884     } catch (...) {
91885       {
91886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91887       };
91888     }
91889   }
91890   jresult = result;
91891   return jresult;
91892 }
91893
91894
91895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
91896   float jresult ;
91897   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91898   float arg2 ;
91899   float arg3 ;
91900   float arg4 ;
91901   float result;
91902
91903   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91904   arg2 = (float)jarg2;
91905   arg3 = (float)jarg3;
91906   arg4 = (float)jarg4;
91907   {
91908     try {
91909       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
91910     } catch (std::out_of_range& e) {
91911       {
91912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91913       };
91914     } catch (std::exception& e) {
91915       {
91916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91917       };
91918     } catch (...) {
91919       {
91920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91921       };
91922     }
91923   }
91924   jresult = result;
91925   return jresult;
91926 }
91927
91928
91929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
91930   float jresult ;
91931   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91932   float arg2 ;
91933   float arg3 ;
91934   float result;
91935
91936   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91937   arg2 = (float)jarg2;
91938   arg3 = (float)jarg3;
91939   {
91940     try {
91941       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
91942     } catch (std::out_of_range& e) {
91943       {
91944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91945       };
91946     } catch (std::exception& e) {
91947       {
91948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91949       };
91950     } catch (...) {
91951       {
91952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91953       };
91954     }
91955   }
91956   jresult = result;
91957   return jresult;
91958 }
91959
91960
91961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
91962   float jresult ;
91963   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91964   float arg2 ;
91965   float result;
91966
91967   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91968   arg2 = (float)jarg2;
91969   {
91970     try {
91971       result = (float)(*arg1)->SnapAndClamp(arg2);
91972     } catch (std::out_of_range& e) {
91973       {
91974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91975       };
91976     } catch (std::exception& e) {
91977       {
91978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91979       };
91980     } catch (...) {
91981       {
91982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91983       };
91984     }
91985   }
91986   jresult = result;
91987   return jresult;
91988 }
91989
91990
91991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
91992   float jresult ;
91993   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91994   float arg2 ;
91995   float arg3 ;
91996   float arg4 ;
91997   float arg5 ;
91998   Dali::Toolkit::ClampState *arg6 = 0 ;
91999   float result;
92000
92001   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92002   arg2 = (float)jarg2;
92003   arg3 = (float)jarg3;
92004   arg4 = (float)jarg4;
92005   arg5 = (float)jarg5;
92006   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92007   if (!arg6) {
92008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92009     return 0;
92010   }
92011   {
92012     try {
92013       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92014     } catch (std::out_of_range& e) {
92015       {
92016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92017       };
92018     } catch (std::exception& e) {
92019       {
92020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92021       };
92022     } catch (...) {
92023       {
92024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92025       };
92026     }
92027   }
92028   jresult = result;
92029   return jresult;
92030 }
92031
92032
92033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92034   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92035
92036   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92037   {
92038     try {
92039       (*arg1)->Reference();
92040     } catch (std::out_of_range& e) {
92041       {
92042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92043       };
92044     } catch (std::exception& e) {
92045       {
92046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92047       };
92048     } catch (...) {
92049       {
92050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92051       };
92052     }
92053   }
92054 }
92055
92056
92057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92058   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92059
92060   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92061   {
92062     try {
92063       (*arg1)->Unreference();
92064     } catch (std::out_of_range& e) {
92065       {
92066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92067       };
92068     } catch (std::exception& e) {
92069       {
92070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92071       };
92072     } catch (...) {
92073       {
92074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92075       };
92076     }
92077   }
92078 }
92079
92080
92081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
92082   int jresult ;
92083   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92084   int result;
92085
92086   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92087   {
92088     try {
92089       result = (int)(*arg1)->ReferenceCount();
92090     } catch (std::out_of_range& e) {
92091       {
92092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92093       };
92094     } catch (std::exception& e) {
92095       {
92096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92097       };
92098     } catch (...) {
92099       {
92100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92101       };
92102     }
92103   }
92104   jresult = result;
92105   return jresult;
92106 }
92107
92108
92109 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
92110     return (Dali::RefObject *)jarg1;
92111 }
92112
92113 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
92114     return (Dali::SignalObserver *)jarg1;
92115 }
92116
92117 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
92118     return (Dali::ConnectionTrackerInterface *)jarg1;
92119 }
92120
92121 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
92122     return (Dali::BaseHandle *)jarg1;
92123 }
92124
92125 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
92126     return (Dali::BaseHandle *)jarg1;
92127 }
92128
92129 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
92130     return (Dali::BaseHandle *)jarg1;
92131 }
92132
92133 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
92134     return (Dali::BaseHandle *)jarg1;
92135 }
92136
92137 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
92138     return (Dali::BaseHandle *)jarg1;
92139 }
92140
92141 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
92142     return (Dali::BaseHandle *)jarg1;
92143 }
92144
92145 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
92146     return (Dali::BaseHandle *)jarg1;
92147 }
92148
92149 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
92150     return (Dali::BaseHandle *)jarg1;
92151 }
92152
92153 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
92154     return (Dali::BaseHandle *)jarg1;
92155 }
92156
92157 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
92158     return (Dali::BaseHandle *)jarg1;
92159 }
92160
92161 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
92162     return (Dali::BaseHandle *)jarg1;
92163 }
92164
92165 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
92166     return (Dali::BaseHandle *)jarg1;
92167 }
92168
92169 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
92170     return (Dali::BaseHandle *)jarg1;
92171 }
92172
92173 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
92174     return (Dali::Handle *)jarg1;
92175 }
92176
92177 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
92178     return (Dali::Handle *)jarg1;
92179 }
92180
92181 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
92182     return (Dali::BaseHandle *)jarg1;
92183 }
92184
92185 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
92186     return (Dali::BaseHandle *)jarg1;
92187 }
92188
92189 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
92190     return (Dali::Handle *)jarg1;
92191 }
92192
92193 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
92194     return (Dali::BaseHandle *)jarg1;
92195 }
92196
92197 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
92198     return (Dali::Handle *)jarg1;
92199 }
92200
92201 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
92202     return (Dali::GestureDetector *)jarg1;
92203 }
92204
92205 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
92206     return (Dali::Gesture *)jarg1;
92207 }
92208
92209 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
92210     return (Dali::Handle *)jarg1;
92211 }
92212
92213 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
92214     return (Dali::Actor *)jarg1;
92215 }
92216
92217 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
92218     return (Dali::BaseHandle *)jarg1;
92219 }
92220
92221 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
92222     return (Dali::RefObject *)jarg1;
92223 }
92224
92225 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
92226     return (Dali::Actor *)jarg1;
92227 }
92228
92229 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
92230     return (Dali::GestureDetector *)jarg1;
92231 }
92232
92233 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
92234     return (Dali::Gesture *)jarg1;
92235 }
92236
92237 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
92238     return (Dali::GestureDetector *)jarg1;
92239 }
92240
92241 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
92242     return (Dali::Gesture *)jarg1;
92243 }
92244
92245 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
92246     return (Dali::GestureDetector *)jarg1;
92247 }
92248
92249 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
92250     return (Dali::Gesture *)jarg1;
92251 }
92252
92253 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
92254     return (Dali::BaseHandle *)jarg1;
92255 }
92256
92257 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
92258     return (Dali::Handle *)jarg1;
92259 }
92260
92261 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
92262     return (Dali::BaseHandle *)jarg1;
92263 }
92264
92265 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
92266     return (Dali::Handle *)jarg1;
92267 }
92268
92269 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
92270     return (Dali::Handle *)jarg1;
92271 }
92272
92273 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
92274     return (Dali::Image *)jarg1;
92275 }
92276
92277 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
92278     return (Dali::Image *)jarg1;
92279 }
92280
92281 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
92282     return (Dali::Image *)jarg1;
92283 }
92284
92285 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
92286     return (Dali::RefObject *)jarg1;
92287 }
92288
92289 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
92290     return (Dali::Image *)jarg1;
92291 }
92292
92293 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
92294     return (Dali::Image *)jarg1;
92295 }
92296
92297 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
92298     return (Dali::ResourceImage *)jarg1;
92299 }
92300
92301 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
92302     return (Dali::Actor *)jarg1;
92303 }
92304
92305 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
92306     return (Dali::BaseHandle *)jarg1;
92307 }
92308
92309 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
92310     return (Dali::BaseHandle *)jarg1;
92311 }
92312
92313 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
92314     return (Dali::BaseHandle *)jarg1;
92315 }
92316
92317 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
92318     return (Dali::BaseHandle *)jarg1;
92319 }
92320
92321 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
92322     return (Dali::BaseHandle *)jarg1;
92323 }
92324
92325 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
92326     return (Dali::BaseHandle *)jarg1;
92327 }
92328
92329 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
92330     return (Dali::CustomActorImpl *)jarg1;
92331 }
92332
92333 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
92334     return (Dali::CustomActor *)jarg1;
92335 }
92336
92337 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
92338     return (Dali::BaseHandle *)jarg1;
92339 }
92340
92341 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
92342     return (Dali::Toolkit::Control *)jarg1;
92343 }
92344
92345 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
92346     return (Dali::Toolkit::Control *)jarg1;
92347 }
92348
92349 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
92350     return (Dali::Toolkit::Button *)jarg1;
92351 }
92352
92353 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
92354     return (Dali::Toolkit::Button *)jarg1;
92355 }
92356
92357 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
92358     return (Dali::Toolkit::Button *)jarg1;
92359 }
92360
92361 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
92362     return (Dali::Toolkit::Control *)jarg1;
92363 }
92364
92365 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
92366     return (Dali::Toolkit::Control *)jarg1;
92367 }
92368
92369 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
92370     return (Dali::Toolkit::Control *)jarg1;
92371 }
92372
92373 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
92374     return (Dali::Toolkit::Control *)jarg1;
92375 }
92376
92377 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
92378     return (Dali::Toolkit::Control *)jarg1;
92379 }
92380
92381 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
92382     return (Dali::RefObject *)jarg1;
92383 }
92384
92385 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
92386     return (Dali::Toolkit::Scrollable *)jarg1;
92387 }
92388
92389 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
92390     return (Dali::BaseHandle *)jarg1;
92391 }
92392
92393 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
92394     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
92395 }
92396
92397 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
92398     return (Dali::RefObject *)jarg1;
92399 }
92400
92401 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
92402     return (Dali::Toolkit::Ruler *)jarg1;
92403 }
92404
92405 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
92406     return (Dali::Toolkit::Ruler *)jarg1;
92407 }
92408
92409 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
92410     return (Dali::Toolkit::Scrollable *)jarg1;
92411 }
92412
92413 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
92414     return (Dali::Toolkit::Control *)jarg1;
92415 }
92416
92417 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
92418     return (Dali::Toolkit::Control *)jarg1;
92419 }
92420
92421 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
92422     return (Dali::Toolkit::Control *)jarg1;
92423 }
92424
92425 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
92426     return (Dali::Toolkit::Control *)jarg1;
92427 }
92428
92429 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
92430     return (Dali::BaseHandle *)jarg1;
92431 }
92432
92433 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
92434     return (Dali::BaseHandle *)jarg1;
92435 }
92436
92437 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
92438     return (Dali::Toolkit::Control *)jarg1;
92439 }
92440
92441 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
92442     return (Dali::Toolkit::Control *)jarg1;
92443 }
92444
92445 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
92446     return (Dali::Toolkit::Control *)jarg1;
92447 }
92448
92449 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
92450     return (Dali::Toolkit::Control *)jarg1;
92451 }
92452
92453 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
92454     return (Dali::Toolkit::Control *)jarg1;
92455 }
92456
92457 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
92458     return (Dali::Toolkit::Control *)jarg1;
92459 }
92460
92461 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
92462     return (Dali::Toolkit::PageTurnView *)jarg1;
92463 }
92464
92465 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
92466     return (Dali::Toolkit::PageTurnView *)jarg1;
92467 }
92468
92469 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
92470     return (Dali::Toolkit::Button *)jarg1;
92471 }
92472
92473 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
92474     return (Dali::BaseHandle *)jarg1;
92475 }
92476
92477 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
92478     return (Dali::BaseHandle *)jarg1;
92479 }
92480
92481 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
92482     return (Dali::BaseHandle *)jarg1;
92483 }
92484
92485 #ifdef __cplusplus
92486 }
92487 #endif
92488